Hybrid Rate Control in a Digital Stream Transcoder

ABSTRACT

A rate controller in run-level domain transcoder, which receives a stream of compressed frames carried in a bit stream, selectively determines whether to quantize and/or threshold portions of a frame carried in the stream of frames. The rate controller determines the input size of the frame and based at least in part upon at least a desired size, requantizes and/or thresholds the frame such that the output size of the frame is approximately the desired size.

CROSS-REFERENCE TO RELATED APPLICATION

This application is a continuation of U.S. application Ser. No.10/635,406 filed Aug. 6, 2003, which is a continuation-in-part of U.S.application Ser. No. 10/397,658, filed Mar. 26, 2003, which claimedpriority to U.S. provisional application Ser. No. 60/368,068, filed Mar.27, 2002, all of which are entirely incorporated herein by reference.

TECHNICAL FIELD

The present invention is generally related to broadband communicationsystems, and, more particularly, is related to transcoding compressedstreams of information in broadband communication systems.

BACKGROUND OF THE INVENTION

Modern subscriber television systems (STS) transmit digital content,which is packetized, from a headend to a subscriber. The digital contentis typically provided in a format such as MPEG or in other packetformats known to those skilled in the art. An operator of an STStypically prefers to provide programs in digital format because digitalprograms provide superior fidelity and because digital programs arecompressed so that they generally use less bandwidth than analogprograms. Digital programs are compressed using, in part, a quantizationparameter.

Frequently, the operator of an STS may want to convert a compresseddigital signal of a given bit rate into a compressed digital signal of alower bit rate by using a conventional transcoder to change thequantization parameter. A conventional transcoder used for such apurpose consists of a cascaded decoder and encoder. This combination israther complex and expensive. In the particular case of video signals,some other aspects have to be taken into account. A coded video signalconsists of a succession of encoded video-frames, where each video-frameis subdivided into a two-dimensional array of macroblocks, eachmacroblock being composed of blocks. A video-frame may be in the spatialdomain, which is the pixel domain, and is transmitted in the frequencyor transform domain, which results from a Discrete Cosine Transform(DCT) of the video-frame in the spatial domain. In addition, avideo-frame may be separated into two fields: the top field formed bythe odd lines of the video-frame and the bottom field formed by the evenlines of the video-frame. A macroblock may be conveyed in two differentformats: an interlaced format and a de-interlaced format. In theinterlaced video-frame format, a macroblock is composed of lines fromthe two fields alternately and each DCT-block of the macroblock isformed by data from the two fields. In the de-interlaced format, amacroblock is composed of lines from the two fields, and each DCT-blockof the macroblock is formed by data from only one of the two fields.Each DCT-block of a video-frame is scanned and encoded.

Before a conventional pixel-domain transcoder can requantize a bitstream, the decoder portion of the transcoder converts the bit streaminto pixel domain values. The encoder portion of the transcoder thenrequantizes and converts the pixel domain values back into DCT-domainvalues.

In addition to conventional pixel-domain transcoders, there existconventional DCT-block domain transcoders, which operate in theDCT-block domain. Such a transcoder receives a bit stream and convertsthe bit stream into sets of run-level pairs, where a set of run-levelpairs is a compressed representation of a DCT-block, and then convertsthe sets of run-level pairs into DCT-blocks. The transcoder manipulatesinformation in the DCT-block domain and then reconverts the DCT-blocksback into sets of run-level pairs, which are then converted back into acompressed bit stream. Further details regarding DCT-block domaintranscoders can be found in “A Frequency-Domain Transcoder For DynamicBit-Rate Reduction of MPEG-2 Bit Streams,” Assuncao et. al., IEEETransactions on Circuits and Systems for Video Technology, Vol. 8, Issue8, December 1998, pages 953-967, which is hereby incorporated byreference in its entirety; and “Manipulation and Compositing of MC-DCTCompressed Video,” Chang et al., IEEE Journal on Selected Areas InCommunications, Vol. 13, No. 1, 1995, pages 1-11, which is herebyincorporated by reference in its entirety.

Both the pixel-domain and DCT-block domain transcoders operate on full8×8 blocks of data. In the DCT-domain the DCT blocks are sparselypopulated, since most of the elements in the block are zero. Typically,no more than six of the sixty-four elements in the block have a non-zerovalue. Therefore, what it is sought is a transcoder that operates in therun-level domain because of the large computational savings that resultfrom operating the transcoder in the more compressed run-level domainthan in the expanded pixel or DCT-block domains and that can compress aframe of information to an approximate desired size.

BRIEF DESCRIPTION OF THE DRAWINGS

The preferred embodiments of the invention can be better understood withreference to the following drawings. The components in the drawings arenot necessarily to scale, emphasis instead being placed upon clearlyillustrating the principles of the present invention. Moreover, in thedrawings, like reference numerals designate corresponding partsthroughout the several views.

FIG. 1 is a block diagram of a broadband communications system, such asa subscriber television system, in which the preferred embodiment of thepresent invention may be employed.

FIG. 2 is block diagram of an encoder.

FIGS. 3A and 3B are diagrams of zig-zag scan order.

FIG. 4A is a diagram of a quantized matrix.

FIG. 4B is a diagram of a set of run-level pairs for the quantizedmatrix illustrated in FIG. 4A.

FIG. 4C is a diagram of a set of run-level pairs for the quantizedmatrix illustrated in FIG. 4A.

FIGS. 5A and 5B are illustrative pictures from a sequence of pictures.

FIG. 6A is a partial picture of the picture illustrated in FIG. 5B.

FIG. 6B is a residual picture.

FIG. 7 is a block diagram of a transcoder.

FIG. 8 is a flow chart of steps taken in processing a digital stream.

FIG. 9 is a flow chart of steps taken in requantizing a digital stream.

FIG. 10A shows block diagrams of a run array, level array, andscan-position array.

FIG. 10B shows block diagrams of the run array, the level array, and thescan-position array illustrated in FIG. 10A after requantization.

FIG. 10C shows block diagrams of an updated run array, an updated levelarray, and an updated scan-position array.

FIG. 11 is a block diagram of the processor in the transcoder.

FIG. 12 is a flow chart of steps taken implementingrequantization/thresholding.

FIG. 13 is a graph of bit saving versus requantization parameter.

FIG. 14 is a flow chart of steps taken to determine whether torequantize.

FIG. 15. is a diagram of a threshold function.

FIG. 16 is a flow chart of steps taken to threshold.

FIG. 17 is a block diagram of states of a threshold state machine.

FIG. 18 is a block diagram of selected components of a transcoder.

FIG. 19. is a block diagram of a motion compensated block.

FIG. 20 is a flow chart of steps taken in requantizing and thresholdinga digital stream.

FIG. 21 is a flow chart of steps taken in motion compensation.

FIG. 22 is a flow chart of steps taken in accumulating drift.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

Preferred embodiments of the present invention will be described morefully hereinafter with reference to the accompanying drawings in whichlike numerals represent like elements throughout the several figures,and in which several exemplary embodiments of the invention are shown.The present invention may, however, be embodied in many different formsand should not be construed as limited to the embodiments set forthherein. The examples set forth herein are non-limiting examples and aremerely examples among other possible examples.

Any process descriptions or blocks in flow charts should be understoodas representing modules, segments, or portions of code which include oneor more executable instructions for implementing specific logicalfunctions or steps in the process, and alternate implementations areincluded within the scope of the preferred embodiment of the presentinvention in which functions may be executed out of order from thatshown or discussed, including substantially concurrently or in reverseorder, depending on the functionality involved, as would be understoodby those reasonably skilled in the art of the present invention

One way of understanding the preferred embodiments of the inventionincludes viewing them within the context of a subscriber televisionsystem (STS). Thus, the preferred embodiments of the invention include,among other things, systems and methods for decreasing the size oftransport streams carried by an STS by requantizing in the run-leveldomain blocks of video information.

Because the preferred embodiments of the invention can be understood inthe context of a subscriber television system environment, an initialdescription of a subscriber television system (STS) is provided, whichis then followed by a description of select components that are includedwithin a headend of the subscriber television system. Also, a run-leveldomain transcoder, which implements preferred embodiments of theinvention and which is included in the headend at the headend, isdescribed.

The preferred embodiments of the invention may, however, be embodied inmany different forms and should not be construed as limited to theembodiments set forth herein; rather, these embodiments are provided sothat this disclosure will be thorough and complete, and will fullyconvey the scope of the invention to those having ordinary skill in theart. Furthermore, all “examples” given herein are intended to benon-limiting, and are provided as an exemplary list among many otherexamples contemplated but not shown.

Furthermore, it should be noted that the logic of the preferredembodiment(s) of the present invention can be implemented in hardware,software, firmware, or a combination thereof. In the preferredembodiment(s), the logic is implemented in software or firmware that isstored in a memory and that is executed by a suitable instructionexecution system. If implemented in hardware, as in an alternativeembodiment, the logic can be implemented with any or a combination ofthe following technologies, which are all well known in the art: adiscrete logic circuit(s) having logic gates for implementing logicfunctions upon data signals, an application specific integrated circuit(ASIC) having appropriate combinational logic gates, a programmable gatearray(s) (PGA), a field programmable gate array (FPGA), a digital signalprocessor (DSP) etc. In addition, the scope of the present inventionincludes embodying the functionality of the preferred embodiments of thepresent invention in logic embodied in hardware or software-configuredmediums.

Subscriber Television System

FIG. 1 is a block diagram depicting a non-limiting example of asubscriber television system (STS) 100. In this example, the STS 100includes a headend 102, a network 104, and multiple digital subscribercommunication terminals (DSCTs) 106, which are located at subscriberpremises 105.

It will be appreciated that the STS 100 shown in FIG. 1 is merelyillustrative and should not be construed as implying any limitationsupon the scope of the preferred embodiments of the invention. Forexample, the STS 100 can feature a plurality of any one of theillustrated components, or may be configured with alternativeembodiments for any one of the individual components or with yet otheradditional components not enumerated above. Subscriber televisionsystems also included within the scope of the preferred embodiments ofthe invention include systems utilizing and not utilizing physicalstructured cabling for transmission, such as, but not limited to,satellite systems.

A DSCT 106, which is located at a subscriber's premises 105, providesamong other things, a two-way interface between the headend 102 of theSTS 100 and the subscriber. The DSCT 106 decodes and further processesthe signals for display on a display device, such as a television set(TV) 107 or a computer monitor, among other examples. Those skilled inthe art will appreciate that in alternative embodiments the equipmentfor first decoding and further processing the signal can be located in avariety of equipment, including, but not limited to, a computer, a TV, amonitor, or an MPEG decoder, among others.

At least one content provider 108 provides the STS 100 with digitalcontent, which is formatted in a protocol such as, but not limited to,MPEG. Among other things, a content provider 108 can be a televisionstation that provides “live” or “recorded” programming. A televisionstation will include a camera 110 and an encoder 112. The encoder 112receives content from the camera 110 and processes the content into anMPEG format, which is then provided to the headend 102 of the STS 100.

The headend 102 receives programming signals from the content providers108, and, after processing the content from the content providers 108according to mechanisms described hereinbelow, the headend 102 transmitsprogramming signals to the DSCTs 106 at the subscriber premises 105.Typically, the headend 102 transmits conventional analog signals, whichwill not be discussed, and digital signals.

In one implementation, the digital signals are transmitted in MPEGformat and embodiments of the present invention will be discussed interms thereof. Specifically, embodiments of the present invention aredescribed in terms of MPEG video-frames and video-fields. However, it isto be understood that describing embodiments of the present inventionemploying MPEG video-frames and video-fields is merely for exemplary andclarity purposes and is not a limitation on the scope of the presentinvention. The scope of the present invention is intended to extend toat least to all streams of quantized information. For the purposes ofthis disclosure a frame of information includes video-frames, topvideo-fields, bottom video-fields, and other predetermined blocks ofinformation.

As shown in FIG. 1, selected components of the example headend 102include a communications interface 114, a digital network control system(DNCS) 116, a conditional access (CA) server 118, a video-on-demand(VOD) server 120, a transport stream transmitter 122, a quadrature phaseshift keying (QPSK) modem 124, a router 126, a VOD pump 128, and arun-level domain transcoder 134, which are connected via an Ethernet130. It will be understood by those having ordinary skill in the artthat the exemplary headend 102 can include additional components, suchas additional servers, switches, multiplexers, transport streamtransmitters, among others, or can omit some of the shown selectedcomponents.

Among other things, the DNCS 116 manages, monitors, and controls networkelements and the broadcast of services provided to users. The DNCS 116includes, among other modules, a subscriber database 132 that includesinformation about the subscribers for such purposes as billinginformation and survey data, among others. The DNCS 116 alsocommunicates with the conditional access server 118 to provide forsecure transmittal of content from the headend 102 to the DSCTs 106.

The CA server 118 selectively provides “entitlements” to the DSCTs 106for the services and programming of the STS 100. In other words, amongother things, the CA server 118 determines which DSCTs 106 of the STS100 are entitled to access a given instance of service or program andprovides the selected DSCTs 106 with the necessary keys andauthorizations, among other things, to access the given instance ofservice. In addition, the CA server 118 informs the DNCS 116 of theentitlements of each of the DSCTs 106 in the STS 100 so that eachsubscriber can be properly billed. Furthermore, the CA server 118includes a database (not shown) that includes, among other things, longterm keys, the public keys of the DSCTs 106 and a private key for the CAserver 118. The CA server employs long-term keys, public and privatekeys to securely communicate with the DSCTs 106.

The CA server 118 also provides encryption information to the transportstream transmitter 122 and to the selected DSCTs 106. The transportstream transmitter 122 employs the encryption information to encrypt thecontent of a program and transmits modulated programming, among otherthings, to the DSCTs 110 via the network 104.

The QPSK modem 124 is responsible for transporting the out-of-band IP(Internet protocol) datagram traffic between the headend 102 and theDSCT 106. Data transmitted or received by the QPSK modem 124 may berouted by the headend router 126. Among other things, the headend router126 may be used to deliver upstream data to the various servers, such asthe VOD server 120.

The run-level domain transcoder 134 receives a bit stream 136 thatcarries a stream of MPEG transport packets and outputs a bit stream 138.The bit size of the output bit stream is lower than the input bit stream136. The run-level domain transcoder 134 is adapted to receive operatorinput and, among other things, apply a hybridrequantization-thresholding scheme on the frames of a program carried bythe input bit stream 136. The hybrid requantization-thresholding schemeis performed in the run-level domain and is done such that the framesare reduced in bit size.

MPEG Compression

Before describing the run-level domain transcoder 134 in detail, a briefdescription of MPEG video compression is provided. Further details ofMPEG compression and MPEG in general can be found in MPEG-1 standards(ISO/IEC 11172), the MPEG-2 standards (ISO/IEC 13818) and the MPEG-4standards (ISO/IEC 14496) are described in detail in the InternationalOrganization for Standardization document ISO/IEC JTC1/SC29/WG11 N (June1996 for MPEG-1, July 1996 for MPEG-2, and October 1998 for MPEG-4),which are hereby incorporated by reference.

Typically, a video frame is segmented into horizontal slices, which canextend across the width of the frame or a fraction thereof. Each sliceis made up of macro-blocks, which are 16×16 pixels in size. When a frameis encoded, headers such as a Picture header, slice headers, andmacro-block headers are used to carry information regarding frame andhow the frame was processed. The pixel information of each macro-blockis processed and is compressed using either spatial coding or temporalcompression.

MPEG-2 employs three types of pictures, I-picture, B-picture, andP-picture. I-pictures are pictures that are intra-coded, i.e.,compressed using only spatial compression from that video-frame, whichmeans that they are decompressed without reference to any othervideo-frame. B-pictures and P-pictures are pictures that areinter-coded, i.e., compressed using information from a reference picturesuch as an I-picture or a P-picture, and are also spatially compressed.P-pictures are “predicted” pictures using information from a previousreference picture, and B-pictures are “bi-directionally predicted”pictures using information from a previous reference picture and from asubsequent reference picture. In practice, a B-picture or a P-picture isnot strictly an inter-coded picture, but is instead a combination ofinter-coded macro-blocks and intra-coded macro-blocks. Macro-blocks thatcan be predicted from reference pictures are inter-coded and thosecannot be predicted are intra-coded. Each macro-block has a macro-blockheader associated with it, and the macro-block header identifies themacro-block as being an inter-coded or intra-coded macro-block.

A typical sequence of video pictures in display order is I(1), B(2),B(3), P(4), B(5), B(6), P(7), B(8), B(9), P(10), . . . P(N), I(N+1). TheP-picture P(4) uses information from the I-picture I(1); the B-picturesB(2) and B(3) use information from the I-picture I(1) and P-pictureP(4); the P-picture P(7) uses information from the P-picture P(4); andthe B-pictures B(5) and B(6) use information from the P-pictures P(4)and P(7). The pictures between I(1) and P(N), inclusive, are known as agroup of pictures (GOP) and typically number between 12-16, inclusive.Video pictures are not transmitted in display order. Instead, eachinter-coded picture is transmitted after all of its reference pictureshave been transmitted. Thus, the transmission order for a GOP is I(1),P(4), B(2), B(3), P(7), B(5), B(6), P(10), B(8), B(9), . . . P(N),B(N−2), B(N−1).

In a typical picture for display on a television, a high qualityNational Television System Committee (NTSC) frame is made up ofapproximately 1350 macro-blocks. Common MPEG-2 standards include 4:2:0and 4:2:2. In the 4:2:0 standard, a 16×16 macroblock is represented byfour 8×8 luminescent blocks and two 8×8 color difference blocks, whichare generated by down sampling each axis by a factor of 2. In the 4:2:2standard, the chroma is not down sampled, and consequently there istwice as much chroma information. Thus, in the 4:2:0 standard, a 16×16macroblock is represented by six 8×8 blocks, and in the 4:2:2 standard,a 16×16 macroblock is represented by eight 8×8 macroblocks. All of the8×8 blocks of a macro-block are steered from a reference picture(I-picture or P-picture) to a temporally compressed picture (P-pictureor B-picture) by a common motion vector.

Spatial compression in MPEG-2 is based upon transforming eachmacro-block using a two dimensional discrete cosine transform (DCT) oneach of the 8×8 blocks to convert from the pixel domain to the frequencydomain, also known as the DCT domain. The steps in which an MPEGencoder, such as encoder 112, spatially compresses frames areillustrated in FIG. 2. The encoder 112 includes a transformer 202, aquantizer 204, a scanner 206, and a binary encoder 208. The transformer202 transforms each block of pixel information 210 of a picture into aDCT domain block 212 using a discrete cosine transform. The pixel domainblock 210 is written as a matrix b, whose elements are given as b(n,m),where n and m range from 0 to 7, inclusive. The DCT domain block 212 iswritten as a matrix B, whose elements are given as B(k,j), where k and jrange from 0 to 7, inclusive. The transformer 202 uses the followingequation to transform from pixel domain to DCT domain:

$\begin{matrix}{{{B\left( {k,j} \right)} = {\frac{c(k)}{2}\frac{c(j)}{2}{\sum\limits_{n = 0}^{7}{\sum\limits_{m = 0}^{7}{{b\left( {n,m} \right)}{\cos\left( \frac{{\left( {{2n} + 1} \right) \cdot k}\; \pi}{16} \right)}{\cos\left( \frac{{\left( {{2m} + 1} \right) \cdot j}\; \pi}{16} \right)}}}}}},} & (1)\end{matrix}$

where c(0)=1/√{square root over (2)} and c(n)=1 for n>0.

The zero-frequency (DC) component, B(0,0), is in the top left corner ofDCT domain matrix 212 and the coefficient for the highest frequencies,B(7,7), is in the bottom right hand corner of the DCT domain matrix 212.

The DCT coefficients are not treated equally because the human eye isless responsive to high frequencies than low frequencies. Consequently,the quantizer 204 applies a weight factor to each of the DCTcoefficients while quantizing them. Quantization converts the DCTcoefficients from rational numbers into integers and usually results ina sparse representation of the quantized DCT coefficients, i.e., one inwhich most or a large percentage of the amplitudes of the coefficientsare equal to zero. In one implementation, the quantizer 204 employs thefollowing weight-quantization scheme:

B′(k,j)=int([2B(k,j)+1]·Q·w(k,j)/16,  (2a)

for inter-coded blocks and

B′(k,j)=int(2B(k,j)·Q·w(k,j)/16,  (2b)

for intra-coded block, where int( ) is the integer function, w(k,j) isthe weight factor for element (k,j), and Q is the quantizationparameter. An MPEG decoder would then employ the following inverseweight-quantization scheme:

B(k,j)=nint(B′(k,j)·16·Q/w(k,j)),  (3)

where nint( ) is the nearest integer function. Those skilled in the artrecognize that other quantization schemes, which will not be discussed,but are intended to within the scope of the invention, can also be used.

The scanner 206 performs a zig-zag scan on the quantized DCT matrix (B′)214 and produces a run-level domain matrix (RL) 216, which has thedimensions of (N+1)×2, where N is the number of non-zero coefficients inthe quantized DCT matrix (B′) 214. Finally, a binary encoder 208converts the run-level pairs of the run-level domain matrix (RL) 216into a bit stream using Huffman coding. It should be remembered that thepreferred embodiments of the invention are being described in terms ofMPEG standards, which use Huffman coding. However, the present inventionis not intended to be limited to only MPEG standards and other codingtechniques known to those skilled in the art can be uses in otherpreferred embodiments.

FIGS. 3A and 3B illustrate two possible scan orders that are used inscanning MPEG frames. Other protocols might employ different scan ordersand such scan orders are intended to be within the scope of the presentinvention. The scan order illustrated in FIG. 3A is typicallyimplemented by the scanner 206 for scanning the quantized DCT matrix(B′) 214 when the DCT matrix represents a portion of a non-interlacedvideo-frame. FIG. 3B illustrates the scan pattern that is typicallyimplemented when the DCT matrix represents a portion of an interlacedvideo-fields.

FIG. 4A illustrates an exemplary quantized DCT-domain matrix (B′) 214,and FIG. 4B illustrates the corresponding run-level domain matrix (RL)216 after the scanner 206 has employed the scan pattern illustrated inFIG. 3A on the exemplary DCT-domain matrix 214. In the run-level domain,“run” refers to the number of consecutively scanned coefficients havingthe value of zero that precede a non-zero coefficient, and “level”refers to the amplitude of the non-zero coefficients. The number ofcoefficients having the value of zero preceding the zero-frequency(D.C.) coefficient (B(0,0)=a) is zero, and thus the run-level pair forthe D.C. coefficient is (0, a). The only zero coefficient interposingB(0,0) and B(1,0) is B(0,1), and thus the run-level pair for B(1,0) isgiven by (1, b). All of the coefficients following the B(4,1)coefficient (B(4,1)=h) are zero and are represented by an end-of-blockmarker, denoted by the run-level pair (0,0). Thus, after processing bythe quantizer 204 and the scanner 206, the 64 coefficients in the DCTdomain matrix (B) 212 are now represented by nine pairs of runs andlevels (18 integers). The conversion of 64 numbers into 18 integers(levels) reduces the number of bits necessary to represent the exemplaryDCT-domain matrix 214.

FIG. 4C illustrates an alternative embodiment of a set of run-levelpairs 216. In intra-coded macro-blocks, MPEG-2 treats DC levels, theB(0,0) element of matrix 214, differently from the higher frequencylevels. The DC level of an intra block is encoded separately from the ACcoefficients since the DC coefficient is differentially coded from blockto block and because the human eye is more responsive to lowerfrequencies. Thus, there is no run value associated with the DC levelbecause by definition that run would have to be zero. DC levels ofinter-coded blocks are treated the same other levels.

An MPEG decoder such as the DCT 106 performs inverse operations toconvert a bit stream into frames. The MPEG decoder has a binary decoder(not shown) that, among other things, converts a bit stream into sets ofrun-level pairs, where a set of run-level pairs represents an 8×8 blockof pixels. An inverse scanner (not shown) converts sets of run-levelpairs into 8×8 matrices of DCT quantized coefficients. An inversequantizer (not shown) multiplies the levels by the quotient of thequantization factor Q divided by the weight factor for each of thelevels. Lastly, an inverse transformer (not shown) transforms the levelsback into pixel domain values. Thus, MPEG encoding and decoding involvea lot of computational complexity due to, among other things, the matrixoperations and DCT transformation and inverse transformations.

As previously stated, P-pictures and B-pictures are partially compressedby using information from at least one reference frame. In a sequence ofpictures, there is normally a lot of redundant information that does notchange substantially from one picture to the next. Bandwidth can besaved by sending motion information that is used to map portions of areference frame into an inter-coded frame and then adding a correctionor residual. The concept of inter-coding is illustrated in FIGS. 5-6.

FIGS. 5A and 5B are illustrative pictures 502A and 502B, respectively,in a sequence of pictures. Each of the pictures 502A and 502B aredivided into blocks 504, which are numbered 1-25. In the picture 502A,an ascending airplane 506 is in blocks 504 that are labeled 1, 2, 6 and7, a cloud 508 is in blocks 504 that are label 8, 9, 13 and 14, and sky(not shown) is background in all of the 25 blocks. In the picture 502Bthe airplane 506 is passing in front of the cloud 508. Much of theinformation of picture 502B such as the background sky is contained inpicture 502A, and the picture 502B can be roughly generated byappropriate translations of blocks from the reference frame into apartial picture.

In FIG. 5B, the blocks 13, 14, 15, and 20 are examples of inter-codedblocks because information from blocks 1, 2, 6, and 7 of FIG. 5A is usedto generate the airplane 506. FIG. 5B also shows the nose of a secondplane 510 entering block 5. Block 5 is an example of an intra-codedblock because it cannot be predicted from any of the blocks of picture502A.

FIG. 6A illustrates a partial picture 602. In the partial picture 602,the airplane 506 is generated by referencing frame 502A and using motionvectors to translate the plane 506 from blocks 1, 2, 6 and 7 into blocks13, 14, 15 and 20. The dashed box 604 represents the blocks 1, 2, 6 and7 of frame 502A and illustrates how the plane 506 can be reconstructedby motion information referencing the frame 502A.

After the encoder has generated a partial representation of picture502B, a residual frame 606, which is illustrated in FIG. 6B, isgenerated. The residual frame 606 is the difference between the actualpicture 502B and the partial picture 602. The dashed outline 608 of theairplane represents the difference between the actual airplane 506 ofthe frame 502B and the translated airplane 506 of the partial picture602. The difference compensates for factors such as change of lightingand perspective. Thus, picture 502B is temporally compressed by sendingmotion vectors that translate specific blocks 504 from a referenceframe, in this case frame 502A, and the residual frame 606. The residualframe 606 is compressed using the spatial compression techniquesdescribed hereinabove.

Run-Level Domain Transcoding

Referring to FIG. 7, the run-level domain transcoder 134 includes aninput buffer 702, a vector length decoder (VLD) 704, a processor 706, amemory 708, a vector length encoder (VLE) 710, and an output buffer 712.The input buffer 702 receives the bit stream 136 and provides the bitstream to the VLD 704. Among other things, the VLD 704 parses headerssuch as the picture headers, slice headers, macroblock headers, whichinclude motion vectors, and others from the bit stream and provides theheaders to the memory 708.

In addition, the VLD 704 also parses non-video frames of information andprovides the non-video frames to the memory 708 and parses run-levelpairs from the bit stream and provides the run-level pairs to the memory708. The memory 708 includes a header buffer 714, a run buffer 716, alevel buffer 718, an index buffer 720, and a non-video frame buffer 722.The header buffer 714 includes information from the headers of the MPEGpackets such as, but not limited to, picture headers, slice headers, andmacroblock headers. The run buffer 716 has sets of runs stored therein,and the level buffer 718 has the sets of levels associated with the setsof runs stored therein. For the purposes of this disclosure, a set ofrun-level pairs represents an 8×8 block of DCT coefficients, which inturn are related to a block of pixel values. Stored in the index buffer720 are scan position arrays which are explained hereinbelow.

The processor 706 processes frames in the run-level domain so that,among other things, a processed frame may be represented by fewer bits.In the preferred embodiment, the processor 706 processes multiple setsof run-level pairs in parallel.

In one preferred embodiment of the invention, the processor 706 is ageneral-purpose processor. In alternative embodiments, the processor 706could be, but is not limited to, a digital signal processor (DSP), anFPGA, an ASIC, or any combination of these processing elements.

After processing a frame of information in the run-level domain, theprocessor 706 sends the processed frame to the VLE 710. As those skilledin the art will recognize, processor 706 controls the processing offrames such that the VLE receives video and non-video frames in the samesequence that the frames were received by the input buffer 702.

Among other things, the VLE 710 converts the processed frame into binaryinformation and encapsulates the binary information into multiple MPEGpackets. The VLE 710 converts run-level pairs from pairs of integervalues into binary sequences using well-known techniques such as, butnot limited to, Huffman coding.

The output buffer 712 receives MPEG packets from the VLE 710 andtransmits the MPEG packets in the binary stream 138.

It should be emphasized that the preferred embodiments of the presentinvention are improvements over conventional transcoders, which requiremany more mathematical operations to process a frame because, amongother things, a conventional transcoder expands the frame. Aconventional transcoder that transcodes an MPEG stream is essentially,in general terms, a cascaded MPEG decoder-encoder pair. The MPEG decoderportion of a conventional transcoder receives a bit stream and a VLDprocesses the bit stream to, among other things, recover therefrom setsof run-level pairs. The levels of each set are then inverse quantized,i.e., multiplied by the quotient of the initial quantization parameter(Q₁) divided by a weight factor. Next, each set of run-level pairs isinverse scanned, i.e., converted from a N×2 matrix into an 8×8 matrix oflevels (DCT coefficients). Next, an inverse DCT operation transforms theDCT coefficients back into pixel domain values. Reference frames inpixel domain representation are stored so that they can be used togenerate complete pixel domain frames of inter-coded compressed frames.The pixel domain frames are sent from the MPEG decoder portion of theconventional transcoder to the MPEG encoder portion of the conventionaltranscoder.

In the MPEG encoder portion of a conventional transcoder, an addersubtracts portions of pixel domain reference frames from inter-codedframes to generate the residual frames. Pixel domain reference framesand residual frames are transformed into DCT coefficients by a DCTmodule. Each block of 8×8 DCT coefficients is then requantized using anew quantization parameter Q₂, thereby converting real numbers intointegers, i.e., levels. Next, each 8×8 block of levels is then scannedand converted into sets of run-level pairs. A VLE module receives, amongother things, header information and run-level pairs and processes itsinputs into MPEG packets.

In addition, after a reference frame has been requantized, therequantized reference frame is converted back into pixel domaininformation and buffered so that it can be used to help generatesubsequent inter-coded frames. Specifically, the requantized levels arealso sent to an inverse quantization module, which then multiplieslevels by the quotient of the Q₂ parameter divided by appropriateweighting factor. An inverse DCT module receives the blocks of levelsand transforms the blocks of levels back into pixel domain values. Ifthe reference frame is an intra-coded frame, e.g., an I-picture, thereference frame is stored in a buffer. If the reference frame is ainter-coded frame, e.g., a P-picture, the motion compensation is appliedsuch that pixels of the residual frame are added to pixel values thathave been taken from a previous reference frame to generate the actualinter-coded reference frame, which is then stored in a buffer. Thus,requantizing a bit stream using a conventional transcoder involves manyoperations and inverse operations and initialization operations. Forexample, prior to performing the inverse scan operation, the entire 64element DCT block must be initialized, i.e., set to zero, to prepare forfilling the block with new data. For the 4:2:0 video standard, theinitialization for the inverse scan operation alone would requireapproximately 15.5×10⁶ operations per second for a high resolution NTSCframe. The number of operations per second is calculated using thefollowing equation:

N _(op) =N _(block) ×N _(MB)×64×f=15.5×10⁶  (4)

where N_(blocks) equals 6, N_(MB)=1,350, the number of macroblocks perframe, and f=30 frames per second.

FIG. 8 is a flow chart of steps taken by the run-level domain transcoder134 for implementing requantization of a received MPEG stream. In step802, the VLD 704 parses, among other things, the header information,motion information, non-video frames, from MPEG packets and provides theparsed information to the memory 708. The VLD 704 also decodes thebinary representation of sets of run-level pairs into integer sets ofrun-level pairs and provides the runs and levels of a set to the memory708, where they are buffered in buffers 716 and 718, respectively.

In step 804, the processor requantizes sets of run-level pairs of thecurrent frame by multiplying the quantized levels by the ratio of Q₁/Q₂,where Q₁ is the old quantization factor and Q₂ is the new quantizationfactor. The processor also updates macroblock headers and slice headersof the current frame. Macroblock headers include fields for, among otherthings, Coded Block Pattern (CBP), Macroblock Type (MBTYPE), MacroblockAddress Increment (MBINC), and Quantization Scale Code (QSC), which areupdated after requantization. The QSC is always present in the sliceheader and, optionally, may be present in the macroblock header. Whenthe quantization scale is changed, it is necessary to update theappropriate header, which may be a slice header or a macroblock header.If the requantization is done on a set of run-level pair by set ofrun-level pairs basis, then the quantization scale is changed for in themacroblock headers. Whereas, if the requantization is done on a slice ofblocks, then the quantization scale is changed in the slice header.

In step 806, the VLE 710 encodes run-level pairs and encapsulates framesin MPEG packets.

FIG. 9 illustrates exemplary steps implemented by the processor 706 instep 804. In step 902, the processor 706 extracts at least one set ofruns and levels from buffers 716 and 718, respectively.

In step 904, the processor 706 associates a scan-position array witheach extracted set of run-level pairs. A scan-position array has themaximum dimension of 64 elements, which corresponds to the maximum sizeof the levels in the pairs in a set of run-level pairs. The elements ofthe scan-position array are the scan position of the non-zero levels,i.e., DCT coefficients.

In step 906, the processor applies a requantization technique to thelevels. An example of a requantization technique is given by thefollowing equation:

l ₂=NINT(l ₁ ×Q ₁ /Q ₂),  (5)

where NINT( ) is the nearest-integer operation, Q₁ is the initialquantization parameter, Q₂ is the new quantization parameter, and l₁ isthe value of the level before requantization.

In step 908, the processor 706 determines the runs for the requantizedlevels. Some of the levels will have changed to zero, and consequently,some new run values need to be determined. However, it should beemphasized that the new run values are determined without expanding theupdated levels into an 8×8 matrix or equivalently into a 64×1 matrix.

A set of run-level pairs and its associated scan-position array areillustrated in FIG. 10A as run array 1002, level array 1004, andscan-position array 1006. The run array 1102 and level array 1104correspond to the DCT-matrix illustrated in FIG. 4A. The subscript ofeach of the array elements gives the position of that element for itsparticular array. The value of each non-zero element in thescan-position array is the position of the associated level in thezig-zag scan order starting from zero. The VLD 704 calculates the scanposition for each element of the scan-position array using the followingequations:

i _(n) =r _(n) +i _(n-1)+1  (6a)

for n>0, and

i_(n)=r_(n),  (6b)

for n=0.

FIG. 10B illustrates a temporary run array 1008, a temporary level array1010, and the scan-position array 1006 after requantization, where theruns that have been struck out are associated with levels that have beenset to zero. The processor 706 calculates new run values for thetemporary run array 1008 using the following equations:

r _(n) ′=i _(n) −i _(n-k(n)-1)−1  (7a)

for k(n)<n, and

r_(n)′=i_(n),  (7b)

for k(n)=n, where k(n) is the number of levels that were zeroed in thetemporary level array 1010 interposing the n^(th) element and the firstpreceding non-zero element. For example, k(4)=2 because level l₁ is notzero and levels l₂ and l₃ have been set to zero. Runs that correspond tolevels that are zeroed by requantization are ignored.

FIG. 10C illustrates an updated run array 1012, an updated level array1014, and corresponding set of run-level pairs 1016. The updated runarray 1012 corresponds to the new run values illustrated in FIG. 10B,and the updated level array 1014 corresponds to the non-zero requantizedlevels illustrated in FIG. 10B.

In one preferred embodiment, instead of receiving the updated set ofrun-level pairs 1016, the VLE 710 receives the temporary run array 1008and temporary level array 1010. The VLE 710 is adapted to ignore runsthat are associated with levels that have been set to zero. Thus, in theexemplary arrays illustrated in FIG. 10B, the VLE 710 only Huffmanencodes the run-level pairs (r₀,l₀), (r₁,l₁), (r₄,l₄) and (r₆,l₆). Thisembodiment does not require reformatting the size of the buffers for theupdated run array 1012 and the updated level array 1014.

It should be noted that tremendous computational efficiencies are had byusing the scan-position array in calculating the new run values. Theupdated runs are computed using single-instruction-multiple-datatechniques (parallel processing) on a programmable digital signalprocessor (DSP).

Working in the run-level domain instead of the pixel domain or DCT-blockdomain provides for increased computational efficiency. As previouslynoted, just initializing the inverse DCT matrix requires approximately15.5×10⁶ operations per second for high quality NTSC frames. Because weare working in the run-level domain instead of the pixel domain, theseinitialization operations do not need to be performed. As anotherexample of increased efficiency consider operations for quantization.Take for example a 3-megabit per second (mbits/s) NTSC MPEG-2 bit streamwith an average number of DCT coefficients of 30,000 per picture.Assuming two operations per requantized coefficient in equation 5,requantization requires an operation count of 30,000×2×30=1.8×10⁶operations per second. Whereas, for a conventional transcoder the numberof operations per second for inverse quantizing or requantizing would be6×64×1,350×30×nq=15,552,000 nq operations per second where nq is thenumber of operations for quantizing of a coefficient. The number ofoperations for quantization or inverse quantization depends upon thequantization/inverse quantization scheme that is implemented, but whenthe quantization scheme of equation 2 is implemented, nq isapproximately 3 or 4, and consequently, for a conventional transcoder,requantization requires approximately 47×10⁶-62×10⁶ operations.

Run-Level Domain Thresholding

In one preferred embodiment, the bit size of the frames are reduced byselectively zeroing levels in sets of run-level pairs, as opposed tozeroing through requantization. In this embodiment, the processor 706determines which levels in a set of run-level pairs are to be zeroed andthose levels are then set to zero. After setting those levels to zero,the processor 706 then determines new run values using equation 7. Theprocessor 706 is adapted to determine which levels to selectively set tozero using criteria such as level magnitude and frequency. The processor706 selectively zeros levels of a set of run-level pairs using athreshold function that selectively zeros levels based upon bothamplitude and frequency. Because the human eye is more responsive tolower frequencies than higher frequencies, the threshold for zeroinghigh frequency levels is different from the threshold for low frequencylevel so that the high frequency levels are more predominately zeroed.

Run-Level Domain Rate Control

Referring to FIG. 11, in one preferred embodiment, the processor 706includes a rate controller 1102. In addition to the run buffer 716, thelevel buffer 718, the index buffer 720, and the non-video buffer 722,which were previously described hereinabove, the memory 708 alsoincludes a picture descriptor buffer 1104, a slice descriptor buffer1106, a macro block descriptor buffer 1108, a vector-length-code (VLC)table buffer 1110, and an N-bits buffer 1112. Stored in the VLC tablebuffer 1110 are specific codes that represent particular pairs of runsand levels. Stored in the N-bits buffer 1112 are the sizes of each ofspecific codes stored in the VLC table buffer 1110. When the processor706 receives a video frame, the processor 706 parses the frame andbuffers the picture header, and the macroblock headers in theirrespective buffers 1104, 1106, and 1108. In addition, the processor 706processes the slice headers and the macroblock headers to determinevarious quantities such as the maximum quantization parameter (Q1MAX)that was last used to quantize the levels included in the slice, and theaverage quantization parameter (Q1AVG) that was last used to quantizethe levels included in the slice. Furthermore, the processor 706processes the sets of run-level pairs for each slice and calculatesvarious quantities such as the average of the runs (Run_avg) and theaverage of the absolute value of the levels (LAVG). For each slice, theprocessor 706 also uses the index buffer 720 to calculate the average ofthe scan positions (IAVG).

The rate controller 1102 implements logic for a hybridrequantization/thresholding scheme for reducing the bit size of a framesuch that the reduced bit size of the frame is approximately equal to adesired bit size (N_(D)). Usually the desired bit size (N_(D)) isprovided to the transcoder 134 by the DNCS 116 or by an operator using auser interface (not shown), or by a frame-layer rate control algorithmwhich determines the number of bits in each picture frame based upon atarget bit rate set by an operator.

FIG. 12 illustrates exemplary requantization-thresholding logicimplemented by the processor 706. In step 1202, a frame is received bythe processor 706. The frame is parsed and buffered in memory 708. Therate controller 1102 implements the hybrid requantization-thresholdingscheme on a slice-by-slice basis, and, in one preferred embodiment, thesets of run-level pairs in a slice are handled in parallel. Typically,the processor 706 processes a slice in a working buffer (not shown),while retaining the initial values of the slice in memory 708. As thoseskilled in the art will recognize, the slice is an arbitrary portion ofa picture and other smaller or larger portions of a picture may beutilized and are within the scope and intent of the invention. Forexample, a media processor or digital signal processor may have aninternal cache which limits the portion of the picture which can beprocessed using the techniques set forth below.

The rate controller 1102 initializes parameters that are used inprocessing the entire frame such as an accumulated reduction error (E),and picture-type (P_T), among others. The type of picture, I-picture,P-picture or B-picture, is determined from the picture header, which isstored in picture descriptor buffer 1104. Among other things, the ratecontroller 1102 also determines the number of slices (N_(SLICE)) in theframe and the total size (N_(T)) of the frame and the total content size(C_(T)) of the frame. For the purposes of this disclosure, a frame shallbe considered to consist of two types of information: contentinformation and non-content information. The content information is theaggregate of the sets of run-level pairs of the frame, and thenon-content information is everything else: picture headers, sliceheaders, micro-block headers, motion vectors, etc. Furthermore, for thepurposes of this disclosure, the total size (N_(T)) of the frame isdefined as the size of the frame when the frame is compressed, and thetotal content size (C_(T)) of the frame is defined as the compressed bitsize of the content information, i.e., all of the run-level pairs. Therate controller 1102 also determines the amount of bits that need to beshaved off the frame (N_(S)), where amount to shave off is defined asthe difference between the desired bit size (N_(D)) and the total bitsize (N_(T)), N_(S)=N_(T)−N_(D).

In step 1204, the rate controller 1120 determines quantities such as theslice content size, S_(SIZE)(K), and a reduction threshold, R_(T), andinitializes slice quantities such as N_(SAVED)(K), which is describedhereinbelow. For the purposes of this disclosure, the content size,S_(SIZE)(K), is defined as the compressed bit size of all of therun-level pairs for the Kth slice of the frame. To determineS_(SIZE)(K), the rate controller 1102 checks the VLC table buffer 1110for each run-level pair (J) in the slice to determine whether the VLCtable buffer 1110 includes a specific code representing that pair, andif so, the rate controller 1102 uses the N-bits buffer 1112 to determinethe compressed bit size (VLC_(J)) of that specific code. Some possiblerun-level pairs are not included in the VLC table buffer 1110, and suchrun-level pairs are represented in 24 bits, a 6 bit escape sequencefollowed by six bits for the run and 12 bits for the level. Thus, theslice content size, S_(SIZE)(K), is given by the following equation:

$\begin{matrix}{{{S_{SIZE}(K)} = {{\sum\limits_{J = 0}^{{{Ncoef}{(K)}} - 1}{VLC}_{J}} + {24 \times N_{ESCAPE}}}},} & (8)\end{matrix}$

where Ncoef(K) is the number of levels in the slice, VLC_(J) is thecompressed bit size of the j^(th) run-level pair, which is zero if thej^(th) run-level pair is not one of the specific codes found in the VLCtable buffer 1110, and N_(ESCAPE) is the number of run-level pairs inthe slice that are not found in the VLC table buffer 1110.

The rate controller 1102 also determines the amount of bits to reducefrom the Kth slice, N_(SHAVE)(K) which is given as

$\begin{matrix}{{{N_{SHAVE}(K)} = {{{S_{SIZE}(K)} \times \frac{N_{S}}{C_{T}}} + \frac{E}{N_{SLICE} - K}}},} & (9)\end{matrix}$

where N_(SLICE) is the number of slices in the frame, K ranges from zeroto N_(SLICE)−1, and the accumulated reduction error (E) is theaccumulated difference between the desired bit reduction and the actualbit reduction for previous slices.

The reduction threshold (R_(T)) is give by the following equation:

$\begin{matrix}{R_{T} = \frac{N_{SHAVE}(K)}{S_{SIZE}(K)}} & (10)\end{matrix}$

In step 1206, the rate controller 1102 determines whether to requantizethe slice. Generally, the decision whether or not to requantize is basedat least in part upon a requantization threshold parameter (T) and thereduction threshold (R_(T)). The requantization threshold parameter (T)is provided to the transponder 134 by the DNCS 116 or by an operator, oris computed by a frame-layer rate control algorithm. Typically, if R_(T)is greater than T then the slice is requantized. Other factors such aspicture type and/or the initial quantization parameters used inquantizing the slice, among others, may also be used in thedetermination on whether to requantize or not. If the decision is not torequantize, the rate controller 1102 proceeds to step 1212, otherwise,the rate controller proceeds to step 1208.

In step 1208, the rate controller 1102 requantizes the sets of run-levelpairs of the current slice. In one preferred embodiment, the sets ofrun-level pairs of the slice are requantized in parallel usingtechniques previously described herein.

In step 1210, after the slice has been requantized, the rate controller1102 determines the number of bits saved by requantization. The ratecontroller 1102 uses the VLC table buffer 1110 to determine the newcodes for the requantized run-level pairs and the N-bits buffer 1112 todetermine the number of bits for the codes. For the Kth slice of thecurrent frame the number of bits saved is given by the followingequation:

$\begin{matrix}{{{N\_ saved}(K)} = {{S_{SIZE}(K)} - \begin{pmatrix}{{\sum\limits_{J = 0}^{{{Ncoef}{(K)}} - 1}{VLC\_ NEW}_{J}} +} \\{{N\_ escape}_{new} \times 24}\end{pmatrix}}} & (11)\end{matrix}$

where VLC_NEW_(J) is the compressed bit size of the new j^(th) run-levelpair, which is zero if the new j^(th) run-level pair is not one of thespecific codes found in the VLC table buffer 1110, and N_escape_(new) isthe new number of run-level pairs in the slice that are not found in theVLC table buffer 1110.

Next in step 1212, the rate controller 1102 determines whether to thethreshold the slice. Typically, the thresholding decision is based atleast upon the number of bits saved, N_saved (K), which was initializedto zero in step 1204 and calculated in step 1210. If the number of bitssaved, N_saved (K), is greater than or equal to the amount of bits toshave, N_shave(K), from the slice, the rate controller 1102 proceeds tostep 1218. On the other hand, if N_saved(K) is less than N_shave (K),the rate controller 1102 proceeds to step 1214 and thresholds the slice.Further details of the thresholding are provided hereinbelow.

Next, in step 1216, the rate controller 1102 determines the amount ofbits saved, N_saved(K). The amount of bits saved is the differencebetween the number of bits used to represent the slice in compressedformat, e.g., using Huffman code, and the initial size of the slice incompressed format. Typically the amount of bits saved will not exactlymatch the desired number of bits to shave from a slice, and thedifference from the two values is added to the accumulated reductionerror (E), which is given as E=E+N_shave(K)−N_saved (K). The accumulatedreduction error, E, is used in equation to calculate of the number ofbits to shave from the next slice.

In step 1218, the rate controller 1102 determines whether all of theslices of the frame have been processed, and if so, returns to step1202. Otherwise, it returns to step 1204 and processes the next slice inthe current frame. The processing described hereinabove was described interms of processing a slice of the frame. However, those skilled in theart will recognize that in alternative embodiments, sets of run-levelpairs, which do not define a slice of the frame, could be handled inparallel, or sets of run-level pairs could be processed sequentially.All such embodiments are intended to be within the scope of the currentinvention.

Before discussing the thresholding in detail, a description of how thedetermination of the requantization parameter is determined. FIG. 13 isa graph of □ versus the requantization parameter Q₂, where χ is definedas the quotient of the total size of the representative frame afterrequantization divided by the total size of the representative framebefore requantization. In the region labeled zone 1, the magnitude of Q₂increases from Q₁, which is the original quantization parameter, up toapproximately

which is equal to 31 if a linear quantization scale is used, and 112 ifa non-linear quantization scale is used for the picture. The rate ofchange of χ with respect to Q₂ (dχdQ₂) is discontinuous at Q₂=α, β, δ,and ε and is approximately constant between each of the discontinuities.The region between Q₂=Q₁ to Q₂=α is defined as zone 1 and throughoutthis region there is only an approximate 15% reduction in the size ofthe requantized frame. In the region defined as zone 2, which extendsfrom Q₂=β to Q₂=δ, the requantized frame is reduced by approximately60%-70%, and in the region defined as zone 3, which extends outward fromQ₂=ε, the requantized frame is reduced at least by approximately 75%.The results shown in FIG. 13 is for a representative frame. The actualamount of reduction can vary depending upon variables such as thecontent of the frame, the type of picture, and other variables. Even so,FIG. 13 illustrates that it is normally preferable to use arequantization parameter from zone 2 (or zone 3) as opposed to zone 1,because requantization in zone 1 does not produce a significant savingin size.

As those skilled in the art will recognize, as the requantizationparameter Q₂ is increased, information is lost due to therequantization, which results in a lower quality of picture for theviewer. Thus, a balance between picture quality and size must be struckby the choice of requantization parameter Q₂. Preferably, therequantization parameter Q₂ is not chosen from zone 1 because such aparameter only reduces the size of the requantized frame by at mostapproximately 15%. Instead, it is preferable that thresholding is usedfor such small decreases in the size of the frame. If requantization isperformed, then in one preferred embodiment, the requantization reducesthe size of the current frame to approximately the desired size, N_(D),and then thresholding is performed to further reduce the size such thatthe total size of the frame is even closer to the desired size.

Table 1 lists adjustable parameters, which are provided by the DNCS 116,or the operator, that are used by the rate controller 1102 indetermining whether to requantize. The adjustable parameters include therequantization threshold parameter (T), which in the preferredembodiment is an array, a quantization threshold array QT, which is afunction of picture type (P_T), and LMIN, which is parameter associatedwith the average of the absolute value of the levels in the slice.

TABLE 1 Parameter Example Value T(0) 0.30 T(1) 0.40 T(2) 0.50 T(3) 0.60T(4) 0.70 QT(0, P_T) n/a QT(1, P_T) 7 for P_T = I or P Picture, 9 forP_T = B picture QT(2, P_T) 9 for P_T = I or P Picture, 11 for P_T = Bpicture QT(3, P_T) 12 for P_T = I or P Picture, 14 for P_T = B pictureL_(min) 1

FIG. 14 further illustrates exemplary steps 1400 for determining whetherto requantize the current frame implemented by the rate controller 1102in step 1206. In step 1402, a requantization flag is set to the defaultposition of “false”, and a counter, “J,” is initialized to zero. Next instep 1404, the rate controller 1102 determines whether the reductionthreshold, R_(T), is less than the requantization threshold parameterT(J) for J=0. If the condition R_(T)<T(0) is true, the rate controller1102 drops to step 1418 and is finished, which in this case means thatrequantization is not performed because the reduction threshold is smallenough that the current frame will be reduced to approximately thedesired size by thresholding only. On the other hand, if the conditionR_(T)<T(0) is false, the rate controller 1102 proceeds to step 1406.

In step 1406, the rate controller 1102 increments the counter J, and instep 1408, the rate controller 1102 determines whether all of thefollowing conditions are true: (i) R_(T)<T(J); (ii) Q1MAX<Q₂(J,P_T); and(iii) LAVG>LMIN, where Q1MAX is the maximum quantization parameter thatwas used to requantize the DCT blocks corresponding to the sets of runlevel pairs that make up the slice, and LAVG is the average of theabsolute value of the levels that make up the slice. When the averageabsolute level of the slice LAVG is equal to 1, this means that at leasthalf the levels of the slice have an absolute level of 1. Therefore,requantization by a factor of 2Q₁ will necessarily zero half or more ofthe levels of the slice. Thus, in this situation, it is preferable touse thresholding instead of requantization to reduce the size of theslice. Only if all three conditions are true does the rate controller1102 proceed to step 1416. On the other hand, if at least one of thethree conditions is false, the rate controller 1102 proceeds to step1410 and increments the counter “J”. In step 1412, the rate controller1102 determines whether the counter J is less than 4. The ratecontroller 1102 loops over steps 1408, 1410 and 1412 until either allthree conditions of step 1408 are true or until J=4.

In step 1412, which is reached when J=4, the rate controller 1102determines whether the reduction threshold R_(T) is greater than therequantization threshold parameter T(4). If so, the rate controller 1102proceeds to step 1416 and sets the requantization flag to “true”. If thecondition R_(T)>T(4) is not met, the rate controller 1102 drops to thelast step 1418 and is finished with the requantization flag still set tothe default “false”. However, if the rate controller 1102 reached step1416 from either step 1408 or 1414, the requantization flag is set to“true,” and then the rate controller 1102 drops to the last step 1418and is finished.

Referring back to step 1408, the three conditions of step 1408 areexemplary conditions for determining whether or not to requantize. Thethree conditions are used so that the various factors such as themaximum initialization quantization parameter and picture type areincluded in the decision along with the reduction threshold and theaverage of the absolute value of the levels of the slice. Those skilledin the art will recognize that the conditions listed hereinabove arenon-limiting lists and that other conditions or more conditions or fewerconditions beyond those listed hereinabove for selectively determiningwhether to requantize can also be used.

In one preferred embodiment, the requantization parameter Q₂ for a setof run-level pairs is typically chosen to be 2Q₁ or 4Q₁, where Q₁ is theinitial quantization parameter for the set of run-level pairs. Choosingthe requantization parameter Q₂ to be either 2Q₁ or 4Q₁ is done forcomputational efficiency, and the determination of whether to use 2Q₁ or4Q₁ is based at least in part on the desired size of the requantizedframe. However, it should be noted that the choice of 2Q₁ or 4Q₁ is amatter of implementation, and in alternative embodiments, therequantization parameter Q₂ can be any quantization parameter.Typically, the default position is for Q₂ to equal 2Q₁, but if thecondition R_(T)>T(4), or some other predetermined value, is true, thenthe value of Q₂ is chosen such that Q₂=4Q₁. By choosing therequantization parameter Q₂ to be either 2Q₁ or 4Q₁ the requantizationparameter Q₂ is chosen from zones 2 or 3 of FIG. 13, respectively.Furthermore, it should be remembered that each set of run-level pairs ofthe current slice may not have been quantized with the same initialquantization parameter, and in that case, each set of run-level pairs isrequantized using a requantization parameter that is a multiple of itsinitial quantization parameter, preferably Q₂=2Q₁ or 4Q₁. Alternatively,the entire slice can be requantized using a common requantizationparameter such as Q₂=2Q1max.

FIG. 15 illustrates an exemplary threshold function 1502, which is astaired function having scan index thresholds 1508, which are labeledI(0) through I(2), and level thresholds 1510, which are labeled L(0)through L(2). The rate controller 1102 zeros levels that are beneath thethreshold function 1502. The level labeled 1506A, whose scan position isbetween the scan index thresholds I(0) and I(1), is zeroed because itsabsolute value is less than the level threshold L(0), which extendsbetween the scan index thresholds I(0) and I(1). On the other hand,level 1504A is not zeroed because its absolute value exceeds the levelthreshold L(0). Similarly, the level labeled 1504B is not zeroed, andthe levels labeled 1506B and 1506C are zeroed. In one preferredembodiment, the rate controller 1102 thresholds the levels of the slicein parallel. In this embodiment, all of the sets of run level pairs thatmake up the slice are each thresholded by the same threshold function.Conceptually, as will be described in detail hereinbelow, the ratecontroller 1102 moves the threshold function 1502 horizontally andvertically so that the correct number of levels are zeroed such thatsize of the slice is reduced by approximately the appropriate amount.

Referring to FIG. 16, steps 1600 illustrate an exemplary method tothreshold the levels of a slice. The method starts at step 1602. In step1604 the rate controller 1102 determines the approximate number oflevels (N_thresh(K)) that need to be zeroed so that the size of theslice will be approximately the desired size after thresholding. Thefollowing equation is used to determine N_thresh(K) for the Kth slice ofthe current frame:

$\begin{matrix}{{{N\_ thresh}(K)} = \frac{\left( {{{Ncoef}(K)} - R_{K}} \right) \times R_{T} \times {A\left( {{Run\_ avg}(K)} \right)}}{S_{SIZE}(K)}} & (10)\end{matrix}$

where Ncoef(K) is the number of levels in the Kth slice, R_(K) is thenumber of levels that were zeroed by requantization, Run_avg(K) is theaverage run value of the Kth slice, and A( ) is a weighting functionhaving Run_avg(K) as its argument. It should be noted that R_(K) isinitialized to zero in step 1204, and if requantization is performed,R_(K) is tabulated in step 1208. The weighting function A( ) strengthensthe relationship from bits to levels as a function of the run average inthe slice. Typically, as the average of the runs increases, the appliedweight changes. For example, for an average run of zero, the run levelpairs are coded efficiently using VLC, and consequently, A(0) isempirically determined to be approximately in the range of 1.2. Whereas,when the average of the runs is four, the run level pairs are notefficiently coded using VLC, and in that case, A(4) is empiricallydetermined to be approximately in the range of 0.8.

In one preferred embodiment, the weighting function A( ) is adjusted instep 1216 based upon the actual bits saved by thresholding. This enableson-line learning/feedback of the weighting function A( ) as a functionof the average of the runs.

Next, in step 1606, thresholding parameters are initialized, and thelevels of the slice are buffered.

In step 1608, the rate controller 1102 performs thresholding on thelevels of the slice based upon the current position of the thresholdfunction. The rate controller 1102 determines which levels of thecurrent slice are beneath the threshold function and zeros those levels.

In step 1610, the rate controller 1102 adjusts the threshold function bymoving it vertically or horizontally so that the number of zeroed levelsare closer to the value of N_thresh(K), or the rate controller 1102determines not to adjust the threshold function.

In step 1612, the rate controller 1102 determines whether it is donewith thresholding. If the rate controller 1102 is finished, the methodends in step 1614. Otherwise, the method loops back to step 1608. Eachtime step 1608 is entered, the levels of the slice are reset accordingto the buffered levels of step 1606.

Typically, the number of levels that are set to zero by thresholdingwill not exactly be equal to the desired value of N_thresh(K) or withina predetermined range of the desired value of N_thresh(K). Thus, in onepreferred embodiment, the rate controller 1102 partitions the sets ofrun level pairs into a first group and a second group. The ratecontroller 1102 then adjusts the threshold function for each groupindependently. If the total number of zeroed levels in the first andsecond group is still not within a predetermined range of N_thresh(K),the rate controller 1102 transfers a predetermined number of levels fromthe second group into the first group. The rate controller 1102continues to transfer levels from the second group into the first group,determine the number of threshold levels, and if the number of thresholdlevels is not within the predetermined range of N_thresh(K), transfermore levels from the second group to the first group until the totalnumber of zeroed levels is within the predetermined range.

In one preferred embodiment, the rate controller 1102 implements a statemachine, the states of which are illustrated in FIG. 17, for adjustingthe index and threshold levels of the threshold function. The statemachine can be seen as passing through a level threshold search followedby a scan index threshold search, with states along the way. Thoseskilled in the art will recognize that the threshold functionillustrated in FIG. 15 was an exemplary threshold function having threelevels and that threshold functions having a different number of levelsare intended to be within the scope of the present invention. Forexample, presently described hereinbelow, the rate controller 1102implements a four level threshold function. Parameters that are used bythe state machine are initialized in step 1606 and shown in Table 2.

TABLE 2 Parameter Value L(0) 2 I(0) index_thresh_min SplitindexVal 0 φ0.05 UL (1 + φ.).x N_thresh(K) LL (1 − φ.).x N_thresh(K) STATEFINDING_LEVEL_POS α.(K) 1 + 5// QAVG(K) offset₁ 8 offset₂ 4 offset₃ 6

The parameters are defined as follows:

L(0): level threshold of index segment 0 labeled 1510A in FIG. 15;

I(0): scan index threshold of index segment 0 labeled 1508A in FIG. 15;

SplitIndexVal: the number of levels in the first group when splitindexing is performed;

φ adjustable parameter for defining a thresholding windows;

UL: upper limit on number of number of levels thresholded to zero;

LL: lower limit on number of number of levels thresholded to zero;

α(K):

(K)=1+5//QAVG(K), where // denotes integer division with truncation andQAVG(K) is the average of the initial quantization parameters (Q₁) ofthe slice, and the parameter

(K) is used for setting level threshold for indices greater than 0; and

offset_((1,2,3)): tunable parameters used for setting index thresholdsfor indices greater than 0.

index_thresh_min: 0 for B-frame, 1 for I or P frame

The threshold level (L) for the index segment zero of the thresholdfunction is initialized to 2, and the remaining threshold levels of thethreshold function are given as follows:

L(n)=L(n−1)+

(K),  (13)

where n ranges from 1 to three. The levels are incremented α(K). Becauseα(K) is a function of QAVG(K), the average of the initial quantizationparameters (Q₁) of the slice, the rise in the level threshold from oneindex segment to the next is sensitive to the quantizer scale.

The scan index threshold I(0) for the threshold function is initializedand held at index_thresh_min (I(0)=index_thresh_min) during the levelsearch (states FINDING_LEVEL_POS and FINDING_LEVEL_NEG), and isinitialized to ISTART at the start of the index search, when the stateFAST_INDEX_SEARCH is entered, where ISTART is given as follows:

ISTART=γ×(1−R _(T))×IAVG(K)  (14)

where IAVG(K) is the average scan position of the levels in the Kthslice and γ is a tunable parameter and which is approximately 2.75

For the remaining scan index thresholds n=1 through 3, I(n) is given asfollows:

I(n)=I(n−1)+offset_(n)  (15)

where offset_(n) is specified in Table 2.

All scan index thresholds I(n) for n=0 through 3 are checked to makecertain that they are less than or equal to 63 because the scanpositions only run to 63. If I(n) is greater than 63, it is simply setto 63.

Referring to FIG. 17, conditional expressions are shown inside of dashedellipses, and actions taken by the state machine are underlined. Thestate machine starts in the initial state 1702 which isFINDING_LEVEL_POS.

STATE FINDING_LEVEL_POS:

The purpose of the initial state 1702 is to increment the levelthreshold L(0) until the count of the thresholded levels (cnt) exceedsthe target count (N_thresh(K)), where cnt is the number of levelszeroed. In this state, the threshold function is not moved horizontallyas the state machine attempts to determine the minimum threshold levelsthat satisfy cnt>N_thresh(K). Instead, I(0) is held at index_thresh_minand the lowest level threshold L(0) is incremented by α(K). The levelthresholds L(1), L(2), and L(3) are recomputed as L(n)=L(n−1)+α(K), forn=1, 2, and 3, until the condition cnt>N_thresh(K) is met. Typically,the levels of a set of run-level pairs are populated most densely aroundsmall scan-positions, and consequently, during the index search, the cntwill be backed off of (made lesser) by sliding the threshold function tothe right, e.g., making I(0)>index_thresh_min and recalculatingI(1)−I(3).

To limit the number of iterations through this state, a higher incrementthan α(K) may be used after a predetermined number (IT) of unsuccessfuliterations, where IT is a tunable parameter, e.g., IT=5. For example, ifthe number of iterations is greater IT, the threshold level for theindex segment zero (L(0)) can be given as:

L(0)=L(0)+2×iterations.  (16)

Alternatively, a binary search can be employed. In most cases,especially in B-pictures and P-pictures where the sets of run-levelpairs contain residual information, the final level threshold is oftenthe initial guess of L(0)=2.

After the levels of the threshold function have been raised, if needed,such that the condition cnt>N_thresh(K) is met, the height of thethreshold level L(0) is considered to be a minimum if the last incrementwas α(K). In this case, the level threshold is final and the statemachine moves to the FAST_INDEX_SEARCH state 1706.

However, if instead it took a large number of iterations through thisstate to find L(0) and the last increment was not by α(K), then thethreshold level L(0) is not a minimum. In this case, the state machineproceeds to FINDING_LEVEL_NEG state 1704.

FINDING_LEVEL_NEG:

The FINDING_LEVEL_NEG state 1704 is entered after the FINDING_LEVEL_POSstate 1702 zeroed more than N_thresh(K) levels and the last incrementwas more than α(K). Typically, this situation occurs when there is ahigh number of iterations and the increment for the levels is given byequation 16.

In this situation, the threshold level L(0) is not a minimum and theFINDING_LEVEL_NEG state 1704 decrements L(0) by α(K), while holding theindex threshold at index_thresh_min, until the condition cnt<N_thresh(K)is met or until the threshold level L(0) is back to its initial value.If the condition cnt<N_thresh(K) is met, then the threshold levels havebeen decremented too far, and in that the threshold levels areincremented by α(K).

FAST_INDEX_SEARCH:

The purpose of the FAST_INDEX_SEARCH state 1706 is to quickly find theneighborhood that the final scan index threshold is in by incrementingor decrementing the scan index threshold by a coarse increment, forexample, β=4. The initial scan index thresholds I(n) (n=0 . . . 3) wereset in step 1606. If cnt is less than the lower limit of the indexwindow, LL, and the value of cnt on the last iteration of the statemachine (last_cnt) was less than or equal to LL, then the indexthreshold I(0) is decreased by β On the other hand, if cnt is greaterthan the upper limit, UL, and the preceding cnt (last_cnt) was greaterthan or equal to UL, then the index threshold I(0) is increased by β.The other index thresholds I(n) for n=1 through 3 are set as a functionof the new value of I(0) as specified in Eq. (15) earlier.

If cnt is greater than UL, but the preceding cnt (last_cnt) was lessthan UL, then the fast index search went too far left (towards lowerfrequencies). In this case, the index threshold I(0) is incremented byβ−1 and the state is modified to the MOVING_LEFT state 1710.

If cnt is less than LL, but the preceding cnt (last_cnt) was greaterthan LL, then the fast index search went too far right (towards higherfrequencies). In this case, the index threshold I(0) is decremented byβ−1 and the state is modified to the MOVING_RIGHT state 1708.

MOVING_RIGHT:

When in the MOVING_RIGHT state 1708, the cnt is checked against UL. If(cnt>UL), then the scan index threshold I(0) is incremented by 1. If cntbecomes less than LL, then the MOVING_RIGHT state 1708 went one indextoo far. In this case, the scan index threshold I(0) is decremented by1, and the state machine proceeds to the SPLIT_INDEX state 1712, wherethe SplitIndexVal is set to 8.

If neither of the above conditions are satisfied, i.e. (LL≦cnt≦UL), thenthe state machine proceeds to the DONE state 1714, where state machinereturns the state “Done” and stops.

MOVING_LEFT:

When in the MOVING_LEFT state 1710, the cnt is checked against UL. If(ent>UL), then the scab index threshold I(0) is incremented by 1. If cntbecomes less than LL, then the MOVING_LEFT state 1710 went one index toofar. In this case, the index threshold I(0) is decremented by 1, and thestate machine proceeds to the SPLIT_INDEX state 1712, where theSplitIndexVal is set to 8.

If neither of the two conditions above are met, i.e. (LL<cnt<UL), thenthe state machine proceeds to the DONE state 1714, where state machinereturns the state “Done” and stops.

SPLIT_INDEX:

The SPLIT_INDEX state 1712 splits (or segments) the levels of the sliceinto two segments as defined by SplitIndexVal, so that not all levels ofthe slice are handeled equally. The thresholding operations up until thestate machine enters the SPLIT_INDEX state have SplitIndexVal=0, sothere is no split index thresholding up until this point.

One reason for the SPLIT_INDEX state 1712 is that thresholding at aparticular value of I(0)=t, where t is determined by the MOVING_LEFTstate 1710 or the MOVING_RIGHT state 1708, results in cnt>UL butthresholding with I(0)=t+1 results in cnt<LL. In this case, it isimpossible to find a scan position for the index threshold I(0) suchthat cnt is within the window (LL<cnt<UL). Therefore, in the firstsegment of levels the index threshold I(0) is set to t, and in thesecond segment of the index threshold I(0) is set to t+1. If the totalcnt for both segments is less than UL, then the state machine proceedsto the DONE state 1714, where state machine returns the state “Done” andstops. On the other hand, if the total cnt for both segments is not lessthan UL, then the SplitIndexVal is incremented so that more levels aremoved from the first segment to the second segment. When cnt reaches thecondition (cnt<UL), the state machine proceeds to the DONE state 1714,where state machine returns the state “Done” and stops. Hereinbelow isan exemplary code for performing split indexing over two partitions. Thefirst partition runs from 0 to Ncoeff(K)-SplitIndexVal−1 and the secondpartition runs from Ncoeff(K)-SplitindexVal to Ncoeff(K)−1. Theparameter SplitIndexVal controls where the dividing line between thepartitions is placed. This effectively gives some fine tuning when thecount of the thresholded coefficients is too large (greater than UL) atone scan index threshold but is too small (less than LL) at theneighboring index one away. Therefore, when SplitIndexVal is set tonon-zero, thresholding is done with the threshold function starting atscan index I(0) for the first partition and starting at scan indexI(0)+1 for the second partition.

SplitIndexVal is initialized to zero at the beginning of the slicethresholding and is modified by the state machine to move the count ofthresholded coefficients within the window defined between LL and UL.

Set Rest of Level and Index Thresholds:

L(n) = L(n−1)+ □(K)   (1≦n≦3) I(n) = I(n−1) + offset_(n.) (1≦n≦3) ResetLevels (Level(j) to original values Loop w over 4 thresholds [L(0) I(0)]to [L(3) I(3)] { Loop i from 0 to Ncoeff(K)-SplitIndexVal − 1 { If abs(Level(i) ) > L(n)  AND Scan-Position(i) > I(n) − 1 { Level(i) = 0 } } }Loop w over 4 thresholds [L(0), I(0)] to [L(3) I(3)] { Loop i fromNcoeff(K)-SplitIndexVal to Ncoeff(K) − 1 { If abs( Level(i) ) > L(n) AND Scan-Position(i) > I(n) { Level(i) = 0 } } }

Run-Level Domain Motion Compensation

In an alternative preferred embodiment, the run-level domain transcoder134 not only requantizes levels and/or selectively zeros levels in therun-level domain, but also, in the run-level domain, applies motioncompensation to inter-coded frames. FIG. 18 illustrates the VLD 704 andthe VLE 710 and some of the functional components of that are includedin the processor 706. The processor 706 includes the memory 708, aninverse quantizer 1802, a drift controller 1804, and a quantizer 1806.

The inverse quantizer 1802 receives sets of run-level pairs from the VLD702. The levels in the sets were quantized with the quantization Q₁ byan upstream MPEG encoder. The inverse quantizer 1802 multiplies thelevels in the sets by the quantization parameter Q1 as given is Eq. (3)according to the MPEG standards such as MPEG-2.

The drift controller 1804 receives the sets of unquantized run-levelpairs, each set is denoted by {r, l}, and implements logic foropportunistic motion control in the run-level domain, which will beexplained in detail hereinbelow.

The memory 708 includes DCT-domain motion compensation matrices (G), acurrent frame buffer, and reference frame buffers. The current framebuffer and reference frame buffers are used to buffer frames, where aframe is composed of a group of sets of run-level pairs, and where a setof run-level pairs represents a block of DCT coefficients representing ablock of pixels. The processor 704 processes the current frame using thereference frames and the DCT-domain motion compensation matrices (G) asneeded to, among other things, produce sets of updated run-level pairs.The quantizer 1806 quantizes the sets of updated run-level pairs using anew quantization parameter Q₂, and the drift controller 1804 calculatesnew runs for the requantized sets of run-level pairs. In the preferredembodiment the drift controller 1804 calculates the runs of therequantized sets of run-level pairs in the run-level domain usingequation 7. The drift controller 1804 provides the VLE 710 with theupdated requantized sets of run-level pairs, which then encodes them aspreviously described.

As previously described an inter-coded frame is generated at an MPEGdecoder by adding pixel information from blocks in a reference frame topixels of a residual frame. The MPEG decoder uses motion vectors, whichare included in the headers of the inter-coded frame, to translate ablock of pixel values from a reference frame to the inter-coded frame.Typically, a motion compensated block, one in which information isretrieved from one or more reference frames, is made up of portions ofmore than one reference block. FIG. 19 illustrates a common situation,which occurs when both components of a motion vector are not integermultiples of the block size, e.g., 8 pixels. A motion compensated block1902 is made up of four sub-blocks 1904, which are labeled 1-4, and aresidual block (not shown). Each sub-block 1904 is a portion of areference block 1906. Sub-block 1904(1) is (A×B) in size, where “A” isthe number of rows of pixels and “B” is the number of columns of pixels,and corresponds to the bottom right hand corner of reference block1906(1); sub-block 1904(2) is (A×(8−B)) in size and corresponds to thebottom left hand corner of reference block 1906(2); sub-block 1904(3) is((8−A)×B) in size and corresponds to the top right hand corner ofreference block 1906(3); and sub-block 1904(4) is ((8−A)×(8−B)) in sizeand corresponds to the top left hand corner of reference block 1906(4).The motion vectors, r₁-r₄, translate the reference blocks1906(1)-1906(4) such that the sub-blocks 1904(1)-1904(4) areappropriately positioned.

In matrix form, the motion compensated block 1902 is denoted by d^(mc)and is given by the following equation:

$\begin{matrix}{{d^{mc} = {\sum\limits_{i = 1}^{4}d_{i}}},} & (17)\end{matrix}$

where d_(i) is an 8×8 matrix given by the following equation:

d_(i)=h_(i) ^(nr)b_(i)w_(i) ^(nc),  (18)

where b_(i) is the i^(th) reference block 1906, nr and nc are the numberof rows and columns, respectively, of the sub-block 1904(i), and h_(i)^(nr) and w_(i) ^(nc) are of the form of upper and lower diagonalmatrices having identity sub-matrices. The h matrices for the foursub-blocks 1904 are as follow:

$\begin{matrix}{{h_{1}^{nr} = \begin{bmatrix}0 & I^{nr} \\0 & 0\end{bmatrix}},} \\{{h_{2}^{nr} = \begin{bmatrix}0 & I^{nr} \\0 & 0\end{bmatrix}},} \\{{h_{3}^{nr} = \begin{bmatrix}0 & 0 \\I^{8 - {nr}} & 0\end{bmatrix}},{and}} \\{{h_{4}^{nr} = \begin{bmatrix}0 & 0 \\I^{8 - {nr}} & 0\end{bmatrix}};}\end{matrix}$

and the w matrices are as follows:

$\begin{matrix}{{w_{1}^{nc} = \begin{bmatrix}0 & 0 \\I^{nc} & 0\end{bmatrix}},} \\{{w_{2}^{nc} = \begin{bmatrix}0 & I^{8 - {nc}} \\0 & 0\end{bmatrix}},} \\{{w_{3}^{nc} = \begin{bmatrix}0 & 0 \\I^{nc} & 0\end{bmatrix}},{and}} \\{w_{4}^{nc} = {\begin{bmatrix}0 & I^{8 - {nc}} \\0 & 0\end{bmatrix}.}}\end{matrix}$

Applying the discrete cosine transform to equation 18 yields:

$\begin{matrix}{{D\; C\; {T(d)}} = {{\sum\limits_{i = 1}^{4}{D\; C\; {T\left( d_{i} \right)}}} = {\sum\limits_{i = 1}^{4}{D\; C\; {T\left( h_{i}^{nr} \right)}D\; C\; {T\left( b_{i} \right)}D\; C\; {T\left( w_{i}^{nc} \right)}}}}} & \left( {19a} \right) \\{{D = {{\sum\limits_{i = 1}^{4}D_{i}} = {\sum\limits_{i = 1}^{4}{H_{i}^{nr}B_{i}w_{i}^{nc}}}}},} & \left( {19b} \right)\end{matrix}$

because the h_(i) ^(nr) and w_(i) ^(nc) matrices are unitary orthogonal,the DCT operation is distributive. All of the matrices in equations17-19 are 8×8 in size, and consequently, by arranging the elements ofthe D, D_(i), and B_(i) matrices in a predetermined order, such as thescan order shown in FIG. 3A, each component of equation 19b can berewritten as

D _(i) ′=G _(i)(H _(i) ^(nr) ,W _(i) ^(nc))B _(i)′,  (20)

where the primed matrices are 64×1 in size and G, which is a function ofthe H_(i) and W_(i) matrices, is a 64×64 matrix that is calculated fromthe H_(i) and W_(i) matrices, and where the subscript “i” refers to thei^(th) reference block. As shown in FIG. 19, “i” normally runs from 1-4.However, for the sake of clarity the subscript “i” will be dropped,which means that the magnitude of the components of the motion vector,which extends from the reference frame to the current frame, are each anintegral number of blocks.

Consider matrices a, b, c, d and e, which are all the same size (N×N),where

a=cbd=(cb)d=ed,  (21)

and the (n,m) component of matrix a is given by

$\begin{matrix}{a_{n,m} = {{\sum\limits_{\alpha = 0}^{N - 1}{e_{n,\alpha}d_{\alpha,m}}} = {\sum\limits_{\beta = 0}^{N - 1}{\sum\limits_{\alpha = 0}^{N - 1}{c_{n,\beta}b_{\beta,\alpha}{d_{\alpha,m}.}}}}}} & (22)\end{matrix}$

Each element in the a and b matrices have a one-to-one mapping into scanorder arrays, and the first element of the scan order array(a₀′=a_(0,0)) is the following:

$\begin{matrix}{a_{o}^{\prime} = {{\sum\limits_{\beta = 0}^{N - 1}{\sum\limits_{\alpha = 0}^{N - 1}{c_{0,\beta}d_{\alpha,0}b_{\beta,\alpha}}}} = {\sum\limits_{\gamma = 0}^{N^{2} - 1}{f_{0,\gamma}{b_{\gamma}^{\prime}.}}}}} & (23)\end{matrix}$

Each element of f is determined on a term by term basis according toscan order. For example, using the scan order illustrated in FIGS. 3Aand N=8, b_(o)′=b_(0,0), b₁′=b_(0,1), b₂′=b_(1,0), . . . b₆₃′=b_(7,7),then f_(0,0)=c_(0,0)d_(0,0), f_(0,1)=c_(0,0)d_(1,0),f_(0,2)=c_(0,1)d_(0,0), . . . and f_(0,63)=c_(0,7)d_(7,0).

In a similar fashion, the elements of the G matrix, which for thepurposes of this disclosure is called a DCT-domain motion compensation(MC) matrix, are found. In one preferred embodiment, the memory 708includes a complete set of G matrices to account for all possibleinteger pixel sub-block placements within the motion compensated block.As those skilled in the art are well aware, MPEG-2 allows for half pixeltranslations of a sub-block, which are accomplished through a linearcombination of integer pixel translations. For the sake of clarity,motion vectors that translate a block of pixels from a reference frameinto an inter-coded frame are considered to be integer translations, butthose skilled in the art understand half-integer translations, and suchtranslations are considered to be within the scope of the invention.

In an alternative preferred embodiment, the memory 708 includes acomplete set of partial matrices, which are denoted as G′. In thisembodiment, the partial matrices, G′, are truncated versions of complete64×64 G matrices. The G′ include lower frequency components of thecomplete G matrices. Even though the use of G′ results in the loss ofmotion compensation for some high frequencies, the quality of servicefor the user should not be substantially affected because the human eyeis less responsive to changes in high frequency. Of course, the qualityof service will depend upon the amount of truncation in the G′, and thesize of G′ is determined by the operator of the STS 100.

Equation 20 provides the basis for performing DCT-domain motioncompensation. However, the output of the VLD 704 includes sets ofrun-level (RL) pairs 216, which are of the form [r₀, l₀, r₁, l₁, . . .r_(n-1), l_(n-1), r_(n), l_(n)]^(T), which is short form for a 64element array consisting of zeroes and non-zero coefficients in scanorder. Thus, in order to use equation 13, sets of run-level pairs needto be expanded into 64 element arrays. Instead of expanding sets ofrun-level pairs and then doing matrix multiplication, a computationallyefficient way of calculating motion compensation for a given set ofrun-level pairs can be employed using information from the given set ofrun-level pairs. First, the G(H^(nr), W^(nc)) matrix defines columnarrays g^(n)(H^(nr), W^(nc)), i.e.,

G(H ^(nr) ,W ^(nc))=[g ⁰(H ^(nr) ,W ^(nc)),g ¹(H ^(nr) ,W ^(nc)), . . ., g ⁶³(H ^(nr) ,W ^(nc))],  (24)

where g^(n)(H^(nr), W^(nc)) is the nth column of G(H^(nr), W^(nc)). Forthe given set of run-level pairs, a scan-position array is associatedwith the set of run-level pairs and the elements of the scan-positionarray are given by equation 6. A modified sub-matrix G′, which is madeup of selected columns of the G(H^(nr), W^(nc)) matrix, is determinedbased upon the scan positions. The selected columns are determined fromthe following equation:

n=r₀,  (25a)

for the first selected column and

n=i _(n-1) +r _(n)+1,  (25b)

for subsequent columns, where “i_(n)” is the n^(th) element of thescan-position array, and r_(n) the n^(th) element of the run array. Forexample, consider the exemplary set of run-level pairs illustrated inFIG. 4B and the corresponding run array 1002, level array 1004, andscan-position array 1006, which are illustrated in FIG. 10A. For thisexample, the modified sub-matrix G′ is as follows:

G′=[g⁰,g²,g⁶,g⁷,g⁹,g¹⁰,g¹³,g¹⁹],  (26)

where the selected columns correspond to the values of the level array1004, then

D=G′L,  (27)

where L is the level array matrix 1004.

Run-Level Domain Motion Compensation

FIGS. 20-22 illustrate exemplary logic that is implemented by therun-level domain transcoder 134 for applying motion compensation in therun-level domain to frames that are transcoded. In FIG. 20, steps 2000illustrate one embodiment, among others, for applying a motioncompensation scheme within the transcoder 134, responsive to thetranscoder 134 selectively reducing the bit size of a frame using eitherrequantization or thresholding or both requantization and thresholding.In FIG. 21, non-limiting exemplary steps 2100 illustrate one embodimentof the motion compensation scheme. In FIG. 22, non-limiting exemplarysteps 2200 illustrate one embodiment of accumulating drift, which isintroduced by requantization or thresholding or both requantization andthresholding and which is used in the motion compensation schemeillustrated in FIG. 21. In FIGS. 20-22, levels that have been processedby requantization, wherein the quantization parameter has been changedfrom Q₁ to Q₂, and levels that have been processed by thresholding aredenoted with primes, e.g., 1′, whereas, levels that have not beenrequantized (change of quantization parameter) or have not beenthresholded are not primed, e.g., 1.

Referring to FIG. 20, in step 2002 the processor 706 receives a currentframe from the VLD 704. The current frame includes, among other things,headers, and sets of quantized run-level pairs denoted by {r, l(Q_(i))}.If the current frame is inter-coded, it also includes among other thingsmotion vectors. A consequence of requantization and/or thresholding is adrift in the levels of inter-coded frames. In a conventional transcoderthat converts a frame back into pixel domain values, the drift iscompensated by performing standard motion compensation on the differenceof the pre-transcoded and transcoded reference frames, and performing aDCT of the result. The accumulated drift (D) is made up of sets ofaccumulated drift, each set corresponding to a macroblock of pixels,wherein the sets of accumulated drift are in the run-level domain. Eachset of accumulated drift has a scan-position array associated with it.When an I-picture, the first picture in a GOP, is received, theaccumulated drift (D) is set to zero. After the I-picture has beenprocessed by requantization and/or thresholding, the drift for each setof run-level pairs, i.e., the difference between the incoming levels andthe processed levels, is determined, and the scan-positions of drift arethen determined. Alternatively, the scan-positions of the incominglevels can be used for the scan-positions of the drift. In that case,for a particular set of drifts, the drift associated with a particularscan position will be zero, if the incoming level and the processedlevel did not change. The accumulated drift (D) is buffered and used tocorrect inter-coded frames.

In step 2004, the drift controller 1804 initializes the parameters usedfor processing a slice of the current frame. Among other things, thedrift controller 1804 determines the amount of bits to shave off of thecurrent slice and initializes quantization parameters and thresholdingparameters. In step 2006, the drift controller 1804 determines whetherthe current frame is an I-picture. If the current frame is an I-picture,the drift controller 1804 proceeds to step 2008 and applies motioncompensation to the current slice of the current frame. Typically,P-pictures and B-pictures are also requantized as part of motioncompensation and will be discussed hereinbelow. After determining thatthe current frame is an I-picture, or after determining the currentframe is not an I-picture and applying motion compensation on thecurrent slice of the current frame, the drift controller 1804 proceedsto step 2010 and determines whether to requantize the slice and whetherthe current frame is an I-picture. The drift controller 1804 proceeds tostep 2012 only if both conditions are met, i.e., that the current frameis an I-picture and that it should be requantized. As previouslydescribed hereinabove, the determination to requantize or not ispreferably based upon multiple parameters such as, but not limited, thereduction threshold (R_(T)), picture type, the maximum initialquantization parameter, and other parameters. As will be explainedhereinbelow, if the current frame is a B-picture or P-picture, then aspart of the motion compensation performed in step 2008 the driftcontroller 1804 determines whether to requantize the current slice, andif so, requantizes the current slice.

In step 2014, the drift controller 1804 determines whether to thresholdthe current slice. Typically, as previously described the decision tothreshold or not is based in part upon parameters such as the reductionthreshold (R_(T)), the number of bits saved by requantization, and theaverage of the absolute values of the levels. However, other parametersincluding fewer parameters, different parameters or more parameters canalso be used in the determination for thresholding.

If the rate controller 1804 decides to threshold the current slice thedrift controller 1804 proceeds to step 2016 and thresholds the currentslice. In one preferred embodiment, the thresholding is performed usingthe thresholding logic illustrated in FIG. 16 along with the statemachine illustrated in FIG. 17. It should be noted that the levels afterthresholding are denoted as L′(Q) (where Q is either Q₁, the initialquantization parameter, or Q₂, the final quantization parameter). If thelevels of the current slice were not requantized, then they arefunctions of Q₁, and if they were requantized, then they are function ofQ₂.

After thresholding, or not thresholding, the drift controller 1804proceeds to step 2018 and determines whether the current frame is aB-picture, and if so proceeds to step 2020 and accumulates the drift inthe levels caused by requantization and/or thresholding. The drift isaccumulated throughout a group of pictures and reset to zero at thebeginning of a new group of pictures.

In step 2022, the drift controller 1804 determines whether the currentslice was the last slice of the current frame, and if so, proceeds tostep 2024. On the other hand, if the current slice is not the last sliceof the current frame, the drift controller 1804 returns to step 2004 andcontinues to process the slices of the current frame until finished.

In step 2024, the drift controller 1804 updates the runs of theprocessed sets of run-level pairs {r,l′(Q)} to produce new sets ofprocessed run-level pairs, which are denoted by {r′,l′(Q)} and updatesthe accumulated drift if the current frame is a reference frame, e.g.,an I-Picture or a P-Picture. The updating of the accumulated drift isdone by buffering the current accumulated drift (T), which wascalculated in step 2020, into the accumulated drift (D). In onepreferred embodiment, the requantization and thresholding are done inparallel, and the calculations of the new runs associated with theprocessed levels (requantized and/or thresholded levels) is done inparallel. In one preferred embodiment, the drift controller 1804 employsequations 6 and 7 in the calculations of the new runs.

In step 2026, the processor 706 sends the processed run-level pairs{r′,l′(Q)} of the current frame to the VLE 710 for processing. In onepreferred embodiment, the processed run-level pairs {r′,l′(Q)} includesupdated run values (r′) that are associated with levels having non-zerovalues and original run values (r) that are associated with levels thathave the value of zero. In this case, the VLE 710 is adapted to ignorerun-level pairs in which the level is zero, i.e., a run-level pairdenoted as (r,0).

Referring to FIG. 21, steps 2100 illustrate an exemplary method ofapplying motion compensation in the run-level domain. In step 2102, thedrift controller 1804 inverse quantizes the levels of the slice toproduce unquantized levels, which are denoted as 1. Motion compensationand drift accumulation, which is illustrated in FIG. 22, are preformedon unquantized levels.

In step 2104, the drift controller 1804 extracts DCT domain MC matrices(G) and selected sets of accumulated drift (D) from the memory 708. Eachof the DCT domain MC matrices in the memory 708 is associated with amotion vector, and the drift controller 1804 uses the motion vectors forthe macro-blocks of the current slice to determine which DCT domain MCmatrices (G) to extract. The selected sets of accumulated driftcorrespond to the reference frame blocks for motion compensated blocksof the current frame, and the drift controller 1804 uses the headerinformation of the current frame to determine which set of accumulateddrift (D_(i)) to extract, where “i” denotes that the set of accumulateddrift corresponds to the “i^(th)” block of the reference frame. Motionvectors of the current frame map sets of accumulated drift to sets ofrun-level pairs of the current frame. When the current frame is aP-Picture, the sets of accumulated drift are from the precedingreference frame such as an I-Picture or P-Picture. When the currentframe is a B-Picture, the sets of accumulated drift are selected fromthe preceding reference frame such as an I-Picture or P-Picture, andfrom the subsequent P-Picture reference frame. In the preferredembodiment, the drift controller 1804 extracts associated scan-positionarrays 1006 for each extracted set of accumulated drift.

In step 2106, for each extracted set of accumulated drift, D_(i), thedrift controller 1804 uses the associated scan-position array to extractselected columns of from its associated DCT domain MC matrix (G) toproduce modified sub-matrices (G′). The columns of the modifiedsub-matrices G′ are determined from the scan-position arrays. The driftcontroller 1804 also associates scan-position arrays with sets ofrun-level pairs {r,l} of the current slice. The elements of thescan-position array are the scan position of the non-zero DCTcoefficients for each set of run-level pairs. If the scan pattern forthe current frame is not the reference scan pattern, then thescan-positions are mapped into scan-positions of the current frame. Inother words, a particular scan pattern such as the scan patternillustrated in FIG. 3A is the reference, or default, scan pattern, andif the scan pattern of the changes, then the scan pattern is remapped tocorrespond to the reference scan pattern.

In step 2108, for each set of run-level pairs {r,l} of the current slicethe drift controller 1804 calculates motion compensation for theaccumulated drift by matrix multiplication of the modified sub-matrix G′with the associated set of accumulated drift D and the product (G′D) isadded to the unquantized levels. The product (G′D) and the unquantizedlevel (l) are then buffered in memory 708. Typically, as illustrated inFIG. 19, a block in the current frame receives information from fourblocks in a reference frame, and consequently, for a set of levels

$1 = {1 + {\sum\limits_{i = 1}^{4}{G_{i}^{\prime}{D_{i}.}}}}$

Conceptually, the modified sub-matrix G′ maps accumulated driftassociated with a block in reference frame into a motion compensatedblock of the current frame.

In one preferred embodiment, an opportunistic scheme is employed suchthat a given set of run-level pairs {r,l} is equal to the given set ofrun-level pairs {r,l} plus the motion compensated accumulated drift,where only like scan positions of the motion compensated accumulateddrift are added to the given set of current run-level pairs {r,l}.Opportunistic addition is performed so that the sets of run-level pairsdo not have to be expanded into full length arrays, i.e., 64 elementarrays, in order to add the motion compensated drift (G′D) to thelevels.

In step 2110, the drift controller 1804 determines whether the currentslice should be requantized. Typically, the decision to requantize ornot is performed using the logic previously described hereinabove.

In step 2112, the quantizer 1806 requantizes the levels of the currentslice using the quantization parameter Q₂. The requantized sets ofrun-level pairs are denoted by {r,l′(Q₂)}. On the other hand, if thedrift controller 1804 had determined not to requantize the currentslice, then in step 2114, the quantizer 1806 requantizes the levels ofthe current slice using the quantization parameter Q₁. After theunquantized levels have been converted back into quantized levels, l(Q),the drift controller 1804 is done with motion compensation.

FIG. 22 illustrates exemplary steps taken by the drift controller 1804to accumulate drift. In step 2202, the drift controller 1804 inversequantizes the processed levels (l′(Q)) to produce unquantized processedlevels (l′) for each set of levels in the current slice. If the currentframe is an I-Picture, then the drift controller 1804 inverse quantizesthe initial quantized levels (l′(Q₁)) to produce unquantizednon-processed levels (l) for each set of levels in the current slice.However, if the current frame is not an I-Picture, then unquantizednon-processed levels (l) were produced and buffered when motioncompensation was applied in step 2108. In that case, the unquantizednon-processed level (l) of the current slice are extracted from thememory 708.

In step 2204, the drift controller 1804 calculates the currentaccumulated drift that is associated with each set of run-level pairs inthe current slice, and buffers the current accumulated drift in atemporary array (T). For a given set of levels in the current slice, thecurrent accumulated drift is sum of the motion compensation of theaccumulated drift, (G′D), from prior reference frames, plus theinstantaneous drift, the difference in the unquantized non-processedlevels (l) and the unquantized processed levels (l′), i.e.,

$T = {\left( {1 - 1^{\prime}} \right) + {\sum\limits_{i = 1}^{4}{G_{i}^{\prime}{D_{i}.}}}}$

The accumulated drift from prior reference frames (D) is not updateduntil the entire current frame has been processed, so that theaccumulated drift does not include artifacts of the current frame.

In one preferred embodiment, the memory 708 includes buffers for atleast two frames worth of drift so that it can include drift for boththe immediately preceding reference frame (an I-Picture or P-Picture)and the current reference frame (a P-Picture) in order to properlyprocess B-Pictures.

In one preferred embodiment, the drift for different types of framessuch as video-frames, top video-fields, and bottom video-fields areaccumulated in memory 708 separately. In this embodiment, the processor706 determines whether the current frame is a video-frame, i.e.,non-interlaced, or a top video-field, or a bottom video-field using theheader information of the current frame and then extracts theappropriate sets of drift from the memory 708 for motion compensationand updates the appropriate sets of drift.

It should be emphasized, that for the sake of clarity, the steps ofmotion compensation were described in a sequential manner. However, asthose skilled in the art will recognize, the steps could be implementedin a different order and/or in parallel. In one preferred embodiment,steps such as, but not limited to, quantizing, inverse quantizing,calculation of new run values, and linear operations of matrices aredone in parallel in enhance computational efficiency. Furthermore, itshould be noted that the motion compensation is performed in therun-level domain because the sets of run-level pairs are not expandedinto DCT-domain matrices. Thus, computational efficiency is had by notinverse scanning sets of run-level pairs into DCT-domain matrices and,then after processing, scanning the DCT-domain matrices back into setsof run-level pairs.

In one preferred embodiment, the motion compensation is implementedusing expanded level arrays, which are 64×1 in size. In this embodiment,the sets of quantized run-level pairs {r,l(Q₁)}, the sets of unquantizedrun-level pairs {r,l}, the sets of requantized run-level pairs{r,l′(Q₂)}, and the sets of unquantized-requantized run-level pairs{r′,l′} are expanded such that the levels are now in scan order. Becausethe various sets of run-level pairs are expanded, the matrix operationsin steps 2014, 2026, and 2034 are done for each level according to scanorder.

In one preferred embodiment, B-Pictures are processed without motioncompensation. In other words, for a B-Picture steps 2100 are skippedover. Motion compensation of B-Pictures can be skipped becauseB-Pictures are not used as reference pictures and any drift error in theB-Pictures is not accumulated and, consequently, is used in the motioncompensation of subsequent pictures. Since many MPEG-2 streams contain amajority of B-Pictures, computational efficiency is enhanced by notdoing motion compensation for B-Pictures.

Although exemplary preferred embodiments of the present invention havebeen shown and described, it will be apparent to those of ordinary skillin the art that a number of changes, modifications, or alterations tothe invention as described may be made, none of which depart from thespirit of the present invention. Changes, modifications, and alterationsshould therefore be seen as within the scope of the present invention.It should also be emphasized that the above-described embodiments of thepresent invention, particularly, any “preferred embodiments” are merelypossible non-limiting examples of implementations, merely setting fortha clear understanding of the principles of the inventions.

1. An apparatus comprising: a processor adapted to receive a quantizedframe; determine the number of bits to shave from a given portion of thequantized frame (N_(SHAVE)); determine for the given portion an initialcontent size (S_(INT)), which is defined as the number of bitsrepresenting the given portion when initial content information of thegiven portion of the quantized frame is compressed; determine areduction threshold (R_(T)), wherein the reduction threshold is given asR_(T)=N_(SHAVE)/S_(INT); determine whether to requantize the givenportion of the quantized frame based at least in part upon the reductionthreshold; and responsive to determining to requantize the given portionof the quantized frame, requantize in the run-level domain the givenportion of the quantized frame.
 2. The apparatus of claim 1, wherein thereceived quantized frame is made up of multiple blocks arranged in asequence, and each block is represented by at least one set of run-levelpairs, and the given portion of the quantized frame is represented bythe at least one set of run-level pairs.
 3. The apparatus of claim 2,wherein the given portion of the quantized frame is a slice of thequantized frame, and the at least one set of run-level pairsrepresenting a block of the slice is processed in parallel.
 4. Theapparatus of claim, 1 wherein the processor is further adapted todetermine a total content size (C_(T)) of the quantized frame, whereinthe total content size (C_(T)) is defined as the number of bits of theinitial content information when the initial content information iscompressed, and wherein the number of bits to shave (N_(SHAVE)) from thegiven portion is related to the product of the initial content size(S_(INT)) times the quotient of number of bits to shave (N_(S)) from thequantized frame divided by the total content size (C_(T)) of thequantized frame.
 5. The apparatus of claim 4, wherein the processor isfurther adapted to: parse the quantized frame into a plurality of Nportions, wherein the given portion of the quantized frame is the k^(th)portion of the frame to be processed; and determine an accumulatedreduction error (E), wherein the accumulated reduction error is definedas the sum of the difference between a desired bit reduction and anactual bit reduction for each already processed portion of the quantizedframe, wherein the desired bit reduction for each previously processedportion is defined as the number of bits to shave (N_(SHAVE)) from thepreviously processed portion, and wherein the actual bit reduction foreach previously processed portion is defined as the difference between afinal compressed content size of the previously processed portion minusan initial compressed content size of the previously processed portion,and wherein the number of bits to shave (N_(SHAVE)) from the givenportion is given by the equationN_(SHAVE)=(S_(INT)×N_(S)/C_(T))+E/(N+1−k).
 6. The apparatus of claim 5,wherein the processor is further adapted to: determine a final contentsize (S_(FNL)) of the given portion of the quantized frame, which isdefined as the number of bits representing the given portion when thefinal content information of the given portion of the quantized frame iscompressed; and determine an instantaneous reduction error (e), whereinthe instantaneous reduction error is defined as the sum of the finalcontent size (S_(FNL)) plus the number of bits to shave (N_(SHAVE)) fromthe given portion minus the initial content size (S_(INT)), such thate=S_(FNL)+N_(SHAVE)−S_(INT).
 7. The apparatus of claim 1, wherein theprocessor is further adapted to determine a target number (N_(THRESH))of levels to set to zero by thresholding levels of the given portion,wherein the quantized frame is made up of multiple blocks arranged in asequence, and each block is represented by at least one set of run-levelpairs, and the given portion of the quantized frame includes the atleast one set of run-level pairs.
 8. The apparatus of claim 7, whereinthe target number (N_(THRESH)) of levels is related to the product ofthe number of levels in the given portion of the quantized frame timesthe quotient of the reduction threshold (R_(T)) divided by the initialcontent size (S_(INT)).
 9. The apparatus of claim 7, wherein the givenportion of the quantized frame includes multiple sets of run-levelpairs, and wherein the processor is further adapted to: associate a scanposition with each level in the given portion; determine a number oflevels (CNT) beneath a threshold function having a predetermined widthand height profile, wherein a particular level is beneath the thresholdfunction responsive to the scan position of the particular level beinggreater than a specific scan position and responsive to a magnitude ofthe particular level being less than a particular height; responsive tothe number of levels (CNT) beneath the threshold function being within apredetermined range of the target number (N_(THRESH)), set the magnitudeof the levels beneath the threshold function to zero; and responsive tothe number of levels (CNT) beneath the threshold function being outsideof the predetermined range of the target number (N_(THRESH)), adjust thethreshold function by changing the height profile of the thresholdfunction.
 10. The apparatus of claim 9, wherein the threshold functionextends over a first range of scan positions and the processor adjuststhe threshold function by shifting the relative location of thethreshold function such that the threshold function extends over asecond range of scan positions.
 11. The apparatus of claim 9, whereinthe threshold function extends over a first range of scan positions andto adjust the threshold function the processor is adapted to: partitionthe levels of the given portion into a first group and a second group oflevels; associate a second threshold function with the second group oflevels, wherein the second threshold function extends over the secondrange of scan positions; (a) determine the number of levels (CNT1)beneath a first threshold function, wherein a first particular level isbeneath the first threshold function responsive to the scan position ofthe first particular level being with the first range of scan positionsand responsive to a magnitude of the first particular level being lessthan a first specific height; (b) determine the number of levels (CNT2)beneath the second threshold function, wherein a second particular levelis beneath the second threshold function responsive to the scan positionof the second particular level associated with the second range of scanpositions and responsive to a magnitude of the second particular levelbeing less than a second specific height; (c) responsive to the sum ofCNT1 and CNT2 being within the predetermined range of the target number(N_(THRESH)), set the magnitude of the levels beneath the first andsecond threshold functions to zero; and (d) responsive to the sum ofCNT1 and CNT2 being outside of the predetermined range of the targetnumber (N_(THRESH)), transfer a predetermined number of levels from thefirst group to the second group, wherein the processor includes logic,which, responsive to the sum of CNT1 and CNT2 being outside of thepredetermined range of the target number (N_(THRESH)), is adapted torepeat (a), (b), (c), and (d) until the sum of CNT1 and CNT2 is withinthe predetermined range of the target number (N_(THRESH)).
 12. Anapparatus comprising: a processor adapted to: receive a decompressedframe; determine the number of bits to shave from the frame (N_(SHAVE));determine an initial content size (S_(INT)) of the frame, which isdefined as a number of bits in the frame before the content informationof the frame is compressed; determine a final content size (S_(FNL)) ofthe frame, which is defined as the number of bits in the frame when thecontent information of the frame is compressed; determine a reductionerror (e) for the frame, wherein the reduction error comprises(e)=S_(FNL)+N_(SHAVE)−S_(INT); and accumulate the reduction error withreduction errors from previously processed frames, wherein theaccumulated reduction error is used in processing subsequent frames. 13.The apparatus of claim 12, wherein to determine the number of bits toshave (N_(S)) from the frame the processor is further adapted to:determine a total size (N_(T)) of the frame, wherein the total size(N_(T)) is number of bits of the frame when the frame is compressed, andwherein number of bits to shave (N_(S)) is defined as a differencebetween the total size (N_(T)) and a desired size (N_(D)), such thatN_(S)=N_(T)−ND.
 14. A method comprising the steps of: receiving in afirst bit stream a compressed frame having compressed contentinformation and non-content information therein, the compressed framehaving a first bit size (N_(T1)), and the compressed content informationhaving a first bit size (C_(T1)); determining an approximate number ofbits to shave (N_(S)) from the compressed frame; decoding the compressedframe such that the frame is represented by initial content informationformatted in sets of run-level pairs, wherein each set of run-levelpairs is defined by a set of levels and an associated set of runs;associating a scan position with a level in one of the sets of run-levelpairs; decomposing the sets of run-level pairs into sets of levels andsets of runs; generating content information from the sets of levels andsets of runs; and encoding the frame using the content information. 15.The method of claim 14, further including the steps of: (a) parsing theframe into a plurality of portions, each portion having at least one setof run-level pairs; (b) buffering a copy of a given portion; (c)thresholding in a run-level domain the levels in the given portion ofthe frame; and (d) calculating new run values for the runs in thethresholded given portion.
 16. The method of claim 15, wherein the stepof processing further includes the steps of: (e) determining a set ofthreshold differences (D) by subtracting the levels in the thresholdedgiven portion from the levels in the buffered copy of the given portion;(f) buffering the set of threshold differences; (g) determining for eachlevel of the given portion the scan position thereof; (h) associating ascan-position array with the set of threshold differences (D), whereinthe elements of the scan-position array include the determined scanpositions; and (i) buffering the scan-position array.
 17. The method ofclaim 16, wherein the step of processing further includes the steps of:(j) determining the number of levels, which have the value of zero andwhich precede the first non-zero level, in the thresholded given portionof the frame; and (k) determining the number of levels, which have thevalue of zero and which interpose non-zero levels, in the thresholdedgiven portion of the frame.
 18. The method of claim 16, wherein steps(b) through (i) are repeated for each portion of the frame, and furtherincluding the steps of: (j) determining a second approximate number ofbits to shave (N_(S2)) from a second compressed frame; (k) decoding thesecond compressed frame such that the second frame is represented byinitial content information formatted in sets of run-level pairs,wherein each set of run-level pairs is defined by a set of levels and anassociated set of runs, and wherein the compressed size of the contentinformation is C_(T2); (l) applying motion compensation to the sets ofrun-level pairs of the second frame using the sets of thresholddifferences (D) to produce therefrom motion compensated contentinformation; (m) thresholding the motion compensated content informationof the second frame to produce therefrom final content information forthe second frame; and (n) encoding the final content information for thesecond frame, wherein the size of the encoded final content informationfor the second frame is approximately given by C_(T2)−N_(S2).
 19. Themethod of claim 18, wherein step (1) further includes the steps of: (o)extracting a particular set of threshold differences from the bufferusing header information of the second frame; (p) matrix multiplying theparticular set of threshold differences with a particular DCT-domainmotion compensation matrix (G) to produce therefrom a set of motioncompensated threshold differences (T); (q) adding the set of motioncompensated threshold differences (T) to levels of the second frame; (r)thresholding in the run-level domain the levels in a second givenportion of the second frame; and (s) calculating new run values forlevels in the second portion.
 20. The method of claim 19, wherein eachelement of the set of motion compensated thresholded differences (T) isassociated with a scan position, and wherein step (q) further includesthe step of: (t) determining for each level of the second given portionthe scan position thereof; and (u) adding the elements of the set ofmotion compensated threshold differences (T) to the levels of the secondgiven portion, wherein only when the scan position that is associatedwith a particular element of the set of motion compensated thresholddifferences (T) matches the scan position of a particular level is theparticular element of the set of motion compensated thresholddifferences (T) added to the particular level.